Mybatis 笔记

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();
  			}
  		}
  	}
  }
  
  

• 问题

  1. 数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。使用数据库连接池可解决此问题。
  2. Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需改变java代码。使用配置文件？
  3. 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护；
  4. 对结果集解析存在硬编码（查询列名），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">
        
        <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语句。

Demo ：查询

使用Mybatis来实现对DAO的访问，需要实现三个步骤；编写SQL语句、配置Bean的映射文件、加载配置文件测试

• SQL语句、配置XML

  <mapper namespace="user">	
  	
  	
  	
  	
  	<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="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 from user where
    id=#{id}

 

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">
	
	
	<resultMap type="orders" id="ordersResultMap">
		
		<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>
	
	
	<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>
  		<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="user" javaType="user">
  		
  		<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">
		
		<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方式，则使用：

  
  <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  	
  	<property name="mapperInterface" value="cn.itcast.mybatis.mapper.UserMapper" />
  	
  	<property name="sqlSessionFactory" ref="sqlSessionFactory" />
  bean>
  
  
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  	
  	<property name="basePackage" value="cn.itcast.mybatis.mapper" />
  bean>
  每个mapper代理对象的id就是类名，首字母小写
  

逆向工程(不常用)

\1. 逆向工程生成的代码只能做单表查询

\2. 不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。

\3. 一张表会生成4个文件