Mybatis note
概念
持久层框架,和DBUtils/Hibernate等类似。一个ORM的持久层框架。
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。MyBatis是一个优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的各种statement(statement、preparedStatemnt、CallableStatement)配置起来,并通过java对象和statement中的sql进行映射生成最终执行的sql语句,最后由mybatis框架执行sql并将结果映射成java对象并返回。
差别
Hibernate 易上手而难精通;Hibernate难在如何设计O/R映射关系,在性能与对象模型间难以平衡;缓存与数据加载复杂、SQL优化复杂;尤其当表非常多的时候,维护有难度。
Hibernate有自己的HQL查询,较少使用SQL语句;Mybatis则相反。
JDBC回顾
-
导入数据库驱动,如mysql
-
1、 加载数据库驱动 2、 创建并获取数据库链接 3、 创建jdbc statement对象 4、 设置sql语句 5、 设置sql语句中的参数(使用preparedStatement) 6、 通过statement执行sql并获取结果 7、 对sql执行结果进行解析处理 8、 释放资源(resultSet、preparedstatement、connection)
-
Demo
public static void main(String[] args) { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { // 加载数据库驱动 Class.forName("com.mysql.jdbc.Driver"); // 通过驱动管理类获取数据库链接 connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123456"); // 定义sql语句 ?表示占位符 String sql = "select * from user where username = ?"; // 获取预处理statement preparedStatement = connection.prepareStatement(sql); // 设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值 preparedStatement.setString(1, "王五"); // 向数据库发出sql执行查询,查询出结果集 resultSet = preparedStatement.executeQuery(); // 遍历查询结果集 while (resultSet.next()) { System.out.println(resultSet.getString("id") + " " + resultSet.getString("username")); } } catch (Exception e) { e.printStackTrace(); } finally { // 释放资源 if (resultSet != null) { try { resultSet.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (preparedStatement != null) { try { preparedStatement.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (connection != null) { try { connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
-
问题
- 数据库连接创建、释放频繁造成系统资源浪费,从而影响系统性能。使用数据库连接池可解决此问题。
- Sql语句在代码中硬编码,造成代码不易维护,实际应用中sql变化的可能较大,sql变动需改变java代码。使用配置文件?
- 使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护;
- 对结果集解析存在硬编码(查询列名),sql变化导致解析代码变化,系统不易维护,如果能将数据库记录封装成pojo对象解析比较方便
使用
Demo V3.2.7版本,构建过程
- 导入Jar包-核心包1,依赖包数个
- 核心配置文件SqlMapConfig.xml、log4j.properties
- POJO文件
- SQL映射文件
- 加载配置文件使用
配置文件
一般使用SqlMapConfig.xml配置,使用DTD模式的限定格式;configuration下可以有多个environment配置,如开发环境、生产、测试等。
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
<!-- 加载配置文件 -->
<mappers>
<mapper resource="mybatis/User.xml"/>
</mappers>
</environments>
Mybatis的日志和SQL输出依赖log4j.properties来配置。
接着,类似于Hibernate根据不同的Bean对象配置XML配置文件,用来解析类到数据库的映射。对象的配置文件中有命名空间namespace,用来控制当前配置的作用范围——用于隔离SQL语句。
<?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">
<!-- 写Sql语句 -->
<mapper namespace="user">
</mapper>
Demo :查询
使用Mybatis来实现对DAO的访问,需要实现三个步骤;编写SQL语句、配置Bean的映射文件、加载配置文件测试
-
SQL语句、配置XML
<mapper namespace="user"> <!-- id:statement的id 或者叫做sql的id--> <!-- parameterType:声明输入参数的类型 --> <!-- resultType:声明输出结果的类型,应该填写pojo的全路径 --> <!-- #{}:输入参数的占位符,相当于jdbc的? --> <select id="queryUserById" parameterType="int" resultType="com.leehao.mybatis.pojo.User"> SELECT * FROM `user` WHERE id = #{id} </select> </mapper>
-
测试——一个标准访问流程
private SqlSessionFactory sqlSessionFactory = null; @Before public void init() throws Exception { // 1. 创建SqlSessionFactoryBuilder对象 SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); // 2. 加载SqlMapConfig.xml配置文件 InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml"); // 3. 创建SqlSessionFactory对象 this.sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream); } @Test public void testQueryUserById() throws Exception { // 4. 创建SqlSession对象 SqlSession sqlSession = sqlSessionFactory.openSession(); // 5. 执行SqlSession对象执行查询,获取结果User // 第一个参数是User.xml的statement的id,第二个参数是执行sql需要的参数; Object user = sqlSession.selectOne("user.queryUserById", 1); // 6. 打印结果 System.out.println(user); // 7. 释放资源 sqlSession.close(); }
-
将SqlSessionFactory抽离出工具类;
public class SqlSessionFactoryUtils { private static SqlSessionFactory sqlSessionFactory = null; static { try { // 1. 创建SqlSessionFactoryBuilder对象 SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); // 2. 加载SqlMapConfig.xml配置文件 InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml"); // 3. 创建SqlSessionFactory对象 sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream); } catch (Exception e) { } } public static SqlSessionFactory getSqlSessionFactory() { return sqlSessionFactory; } }
-
一个模糊匹配的案例
@Test public void demo2(){ //模糊查询 System.out.println("2333"); SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory(); SqlSession sqlSession = sqlSessionFactory.openSession(); List<User> list = sqlSession.selectList("user.queryUserByName", "%张%"); for (User user : list) { System.out.println(user); } }
配置小结
-
#{}和${}
#{}表示一个占位符号,通过#{}可以实现preparedStatement向占位符中设置值,自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值,#{}括号中可以是value或其它名称
${}表示拼接sql串,通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换, ${}可以接收简单类型值或pojo属性值,如果parameterType传输单个简单类型值,${}括号中只能是value。
-
parameterType和resultType
parameterType:指定输入参数类型,mybatis通过ognl从输入对象中获取参数值拼接在sql中。
resultType:指定输出结果类型,mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据,则分别进行映射,并把对象放到容器List中
-
selectOne和selectList
selectOne查询一条记录,如果使用selectOne查询多条记录则抛出异常;selectList可以查询一条或多条记录
-
其他:
- Mybatis默认事务是不提交的,若发生写操作需要使用sqlsession.commit手动提交。
- 或者使用SqlSessionFactory.opensession(true)设置自动提交事务。
插入Demo
插入操作的一个示例:
<insert id="saveUser" parameterType="com.leehao.mybatis.pojo.User">
INSERT INTO `user`
(username,birthday,sex,address) VALUES
(#{username},#{birthday},#{sex},#{address})
</insert>
插入用户,当需要返回插入的ID时:
<!-- 保存用户 -->
<insert id="saveUser" parameterType="cn.itcast.mybatis.pojo.User">
<!-- selectKey 标签实现主键返回 -->
<!-- keyColumn:主键对应的表中的哪一列 -->
<!-- keyProperty:主键对应的pojo中的哪一个属性 -->
<!-- order:设置在执行insert语句前执行查询id的sql,或之后执行查询id的sql -->
<!-- resultType:设置返回的id的类型 -->
<selectKey keyColumn="id" keyProperty="id" order="AFTER"
resultType="int">
SELECT LAST_INSERT_ID() //mysql的内置函数
</selectKey>
INSERT INTO `user`
(username,birthday,sex,address) VALUES
(#{username},#{birthday},#{sex},#{address})
</insert>
//或者使用insert标签中的值简写
<insert id="saveUser" parameterType="cn.itcast.mybatis.pojo.User" useGeneratedKeys="true" keyProperty="id">
更新Demo
<!-- 更新用户 -->
<update id="updateUserById" parameterType="com.leehao.mybatis.pojo.User">
UPDATE `user` SET
username = #{username} WHERE id = #{id}
</update>
删除Demo
<!-- 删除用户 -->
<delete id="deleteUserById" parameterType="int">
delete from user where
id=#{id}
</delete>
Mybatis 体系结构
-
体系结构
-
mybatis配置:SqlMapConfig.xml,此文件作为mybatis的全局配置文件,配置了mybatis的运行环境等信息。mapper.xml文件即sql映射文件,文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。
-
通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂
-
由会话工厂创建sqlSession即会话,操作数据库需要通过sqlSession进行。
-
mybatis底层自定义了Executor执行器接口操作数据库,Executor接口有两个实现,一个是基本执行器、一个是缓存执行器。
-
Mapped Statement也是mybatis一个底层封装对象,它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象,sql的id即是Mapped statement的id。
-
Mapped Statement对sql执行输入参数进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中,输入参数映射就是jdbc编程中对preparedStatement设置参数。
-
Mapped Statement对sql执行输出结果进行定义,包括HashMap、基本类型、pojo,Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中,输出结果映射过程相当于jdbc编程中对结果的解析处理过程。
-
Mybatis解决jdbc编程的问题
-
数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库连接池可解决此问题。
解决:在SqlMapConfig.xml中配置数据连接池,使用连接池管理数据库链接。
-
Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。
解决:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
-
向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。
解决:Mybatis自动将java对象映射至sql语句,通过statement中的parameterType定义输入参数的类型。
-
对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。
解决:Mybatis自动将sql执行结果映射至java对象,通过statement中的resultType定义输出结果的类型。
Dao开发
Mybatis与Hibernate:
Mybatis和hibernate不同,它不完全是一个ORM框架,因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句,并将java对象和sql语句映射生成最终执行的sql,最后将sql执行的结果再映射生成java对象。
Mybatis学习门槛低,简单易学,程序员直接编写原生态sql,可严格控制sql执行性能,灵活度高,非常适合对关系数据模型要求不高的软件开发,例如互联网软件、企业运营类软件等,因为这类软件需求变化频繁,一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性,如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件,工作量大。
Hibernate对象/关系映射能力强,数据库无关性好,对于关系模型要求高的软件(例如需求固定的定制化软件)如果用hibernate开发可以节省很多代码,提高效率。但是Hibernate的学习门槛高,要精通门槛更高,而且怎么设计O/R映射,在性能和对象模型之间如何权衡,以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之,按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构,所以框架只有适合才是最好。
Mybatis的Dao
原始Dao开发方法和Mapper动态代理开发方法。
SqlSession中封装了对数据库的操作,如:查询、插入、更新、删除等。SqlSession通过SqlSessionFactory创建。SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建
-
SqlSessionFactoryBuilder
用于创建SqlSessionFacoty,SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了,因为SqlSession是通过SqlSessionFactory创建的。所以可以将SqlSessionFactoryBuilder当成一个工具类使用,最佳使用范围是方法范围即方法体内局部变量
-
SqlSessionFactory
SqlSessionFactory是一个接口,接口中定义了openSession的不同重载方法,SqlSessionFactory的最佳使用范围是整个应用运行期间,一旦创建后可以重复使用,通常以单例模式管理SqlSessionFactory。
-
SqlSession
SqlSession是一个面向用户的接口,sqlSession中定义了数据库操作方法。
每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用,它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。打开一个 SqlSession使用完毕就要关闭它。通常把这个关闭操作放到 finally 块中以确保每次都能执行关闭
SqlSession session = sqlSessionFactory.openSession(); try { // do work } finally { session.close(); }
传统DAO开发
原始Dao开发方法需要程序员编写Dao接口和Dao实现类。原始Dao开发中存在以下问题:Dao方法体存在重复代码:通过SqlSessionFactory创建SqlSession,调用SqlSession的数据库操作方法。调用sqlSession的数据库操作方法需要指定statement的id,这里存在硬编码,不得于开发维护。
Mapper动态代理
开发规范:
Mapper接口开发方法只需要程序员编写Mapper接口(相当于Dao接口),由Mybatis框架根据接口定义创建接口的动态代理对象,代理对象的方法体同上边Dao接口实现类方法。
Mapper接口开发需要遵循以下规范:
-
Mapper.xml文件中的namespace与mapper接口的类路径相同。
-
Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
-
Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
-
Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同
@Test
public void testQueryById(){
SqlSession sqlSession = sqlSessionFactory.openSession();
//从sqlSession中获取Mapper接口的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//执行
User user = userMapper.queryById(28);
System.out.println(user);
sqlSession.close();
}
小结
selectOne和selectList:动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定,如果返回list则调用selectList方法,如果返回单个对象则调用selectOne方法。
namespace:mybatis官方推荐使用mapper代理方法开发mapper接口,程序员不用编写mapper接口实现类,使用mapper代理方法时,输入参数可以使用pojo包装对象或map对象,保证dao的通用性。
全局配置
SqlMapConfig.xml配置内容
SqlMapConfig.xml中配置的内容和顺序如下:
properties(属性):xml中会覆盖properties的字段
settings(全局配置参数)
typeAliases(类型别名):别名大小写不敏感
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境集合属性对象)
environment(环境子属性对象)
transactionManager(事务管理)
dataSource(数据源)
mappers(映射器)
输入输出映射
Mapper.xml映射文件中定义了操作数据库的sql,每个sql是一个statement,映射文件是mybatis的核心;
单个输入输出
parameterType/resultType是一对值,可以在mapper映射中配置输入输出;
- 传递简单类型:#{}占位符,${value}—sql拼接
- pojo对象属性类型:#{属性名} ${属性名}
- pojo包装对象类型:Pojo类中的一个属性是另外一个pojo
ResultMap
resultType可以指定将查询结果映射为pojo,但需要pojo的属性名和sql查询的列名一致方可映射成功。 如果sql查询字段名和pojo的属性名不一致,可以通过resultMap将字段名和属性名作一个对应关系 ,resultMap实质上还需要将查询结果映射到pojo对象中。 resultMap可以实现将查询结果映射为复杂类型的pojo,比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。
<mapper namespace="com.leehao.mybatis.mapper.OrdersMapper">
<!-- 查询ID -->
<!-- type是查询到的结果类型 -->
<resultMap type="orders" id="ordersResultMap">
<!-- id是查询结果的主键 ,多列则多个-->
<id property="id" column="id"/>
<result property="userId" column="user_id"/>
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
</resultMap>
<!-- id需要和mapper接口方法名一致、参数类型和返回值类型也是 -->
<select id="queryOrderAll" resultMap="ordersResultMap">
select id, user_id, number, createtime, note FROM `orders`
</select>
</mapper>
动态SQL
通过mybatis提供的各种标签方法实现动态拼接sql.
-
if
-
where
<!-- 根据条件查询用户 --> <select id="queryUserByWhere" parameterType="user" resultType="user"> SELECT id, username, birthday, sex, address FROM `user` <!-- where标签可以自动添加where,同时处理sql语句中第一个and关键字 --> <where> <if test="sex != null"> AND sex = #{sex} </if> <if test="username != null and username != ''"> AND username LIKE '%${username}%' </if> </where> </select>
-
sql片段:include通用判断
-
foreach:
关联查询
一对一
-
使用resultType,改造pojo类,把相关关联属性放入待查询的类中;一起映射
<!-- 查询订单,同时包含用户数据 --> <select id="queryOrderUser" resultType="orderUser"> SELECT o.id, o.user_id userId, o.number, o.createtime, o.note, u.username, u.address FROM `order` o LEFT JOIN `user` u ON o.user_id = u.id </select>
-
使用resultMap,改造pojo类,使用pojo引用对象的包装;再映射
<resultMap type="order" id="orderUserResultMap"> <id property="id" column="id" /> <result property="userId" column="user_id" /> <result property="number" column="number" /> <result property="createtime" column="createtime" /> <result property="note" column="note" /> <!-- association :配置一对一属性 --> <!-- property:order里面的User属性名 --> <!-- javaType:属性类型 --> <association property="user" javaType="user"> <!-- id:声明主键,表示user_id是关联查询对象的唯一标识--> <id property="id" column="user_id" /> <result property="username" column="username" /> <result property="address" column="address" /> </association> </resultMap> <!-- 一对一关联,查询订单,订单内部包含用户属性 --> <select id="queryOrderUserResultMap" resultMap="orderUserResultMap"> SELECT o.id,o.user_id,o.number,o.createtime,o.note, u.username,u.address FROM `order` o LEFT JOIN `user` u ON o.user_id = u.id </select>
一对多
<resultMap type="user" id="userOrderResultMap">
<id property="id" column="id" />
<result property="username" column="username" />
<result property="birthday" column="birthday" />
<result property="sex" column="sex" />
<result property="address" column="address" />
<!-- 配置一对多的关系 -->
<collection property="orders" javaType="list" ofType="order">
<!-- 配置主键,是关联Order的唯一标识 -->
<id property="id" column="oid" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
</collection>
</resultMap>
<!-- 一对多关联,查询订单同时查询该用户下的订单 -->
<select id="queryUserOrder" resultMap="userOrderResultMap">
SELECT
u.id, u.username, u.birthday, u.sex, u.address,
o.id oid, o.number, o.createtime, o.note
FROM
`user` u LEFT JOIN `order` o ON u.id = o.user_id
</select>
整合Spring
思路
1、SqlSessionFactory对象应该放到spring容器中作为单例存在。
2、传统dao的开发方式中,应该从spring容器中获得sqlsession对象。
3、Mapper代理形式中,应该从spring容器中直接获得mapper的代理对象。
4、数据库的连接以及数据库连接池事务管理都交给spring容器来完成。
包管理
1、spring的jar包
2、Mybatis的jar包
3、Spring+mybatis的整合包。
4、Mysql的数据库驱动jar包。
5、数据库连接池的jar包。
步骤
-
配置文件
-
使用SqlSessionFactoryBean完成SqlSessionFactory的创建
-
开发:传统Dao接口+实现类时,使用SqlSessionDaoSupport支持(类似HibernateDaoSupport);使用Mapper方式,则使用:
<!-- Mapper代理的方式开发方式一,配置Mapper代理对象 --> <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"> <!-- 配置Mapper接口 --> <property name="mapperInterface" value="cn.itcast.mybatis.mapper.UserMapper" /> <!-- 配置sqlSessionFactory --> <property name="sqlSessionFactory" ref="sqlSessionFactory" /> </bean> <!-- Mapper代理的方式开发方式二,扫描包方式配置代理 --> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <!-- 配置Mapper接口 --> <property name="basePackage" value="cn.itcast.mybatis.mapper" /> </bean> 每个mapper代理对象的id就是类名,首字母小写
逆向工程(不常用)
\1. 逆向工程生成的代码只能做单表查询
\2. 不能在生成的代码上进行扩展,因为如果数据库变更,需要重新使用逆向工程生成代码,原来编写的代码就被覆盖了。
\3. 一张表会生成4个文件