MyBatis介绍及基本使用

前言

关于MyBatis，其实去年学习的时候就开始使用了，不过当时由于刚开始学习框架，对一些东西的理解不是很好，所有在学习MyBatis的时候，虽然有想法想把笔记整理出来作为博客发布，但是一直不敢动手，一方面是对MyBatis的使用不是很熟悉，另一方面是懒吧，囧，这几天趁着有时间重新回顾了MyBaits并且加上接触一些项目，所以就把学习的过程笔记整理出来。

关于MyBatis

MyBatis的前身是Ibatis，是一款优秀的持久层框架官网地址，其对JDBC进行了一系列的封装，提供了自动化的参数注入以及结果集抽取，然而又与Hibernate不同，MyBatis并没有提供全自动的SQL生成，不过，这也提供了极大地便利，我们可以根据情况编写合适的SQL，尤其是对于大牛来说，可以写出性能高一点的SQL，当然，这个我还不行，囧。

关于MyBatis，就不做过多的介绍了，其背景对于我们使用也没有太大的意义

MyBatis基本使用

MyBatis是持久层框架，所有，必不可少要与数据库打交道，这里我使用的是MySQL，首先建立基本的测试库以及测试表

数据来自刘增辉老师的《MyBatis从入门到精通》

create database mybatis default character set utf8 collate utf8_general_ci;use mybatis;# 测试表create table `country`(
  `id` int not null auto_increment,
  `country_name` varchar(255) null ,
  `country_code` varchar(255) null ,
  primary key (`id`)
);# 测试数据insert into country (country_name, country_code)
  values ('中国', 'CN'), 
        ('美国', 'US'), 
        ('俄罗斯', 'RU'), 
        ('英国', 'GB'), 
        ('法国', 'FR');

导入MyBatis以及数据库连接池依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version></dependency><dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.13</version></dependency>

在MyBatis中，需要一个配置MyBatis的配置文件，用于指导MyBatis如何进行工作，如加载mapper文件的位置，类型处理器等等的操作，一般将其放置项目根目录就行

config.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <!-- 配置数据库连接信息 -->
            <dataSource type="UNPOOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://100.69.4.49:1080/mybatis?useUnicode=true&amp;characterEncoding=utf8" />
                <property name="username" value="root" />
                <property name="password" value="huanfeng" />
            </dataSource>
        </environment>
    </environments>

    <!--指定配置文件路径-->
    <mappers>
        <mapper resource="mapper/countryMapper.xml"/>
    </mappers></configuration>

有了MyBatis配置文件之后，还需要多个mapper文件，一般一个mapper对应一个dao对象，也就是一个mapper对应一个对象的操作

这里对应上面的Country表，建立一个CountryMapper.xml文件，放置路径位于mapper/，也可以自己指定，然后修改上面的<mappers>中的路径即可

CountryMapper.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"><!--namespace要全局唯一，用于区分不同的mapper，一般是用对应的接口的全限定名--><mapper namespace="mapper.CountryMapper">
    <!--查询语句，id在同个mapper文件中也要唯一，一般是方法的名称-->
    <select id="selectAll" resultType="Country">
        select
            id,
            country_name as countryName,
            country_code as countryCode
        from country;    </select></mapper>

对应的实例类Country.java

public class Country {    private Long id;    private String countryName;    private String countryCode;    // get() set() toString()}

虽然在简单的一个操作中，不需要配置接口文件也行，不过，一般一个mapper文件都会对应一个接口文件，这里就是CountryMapper.java

public interface CountryMapper {    List<Country> selectAll();
}

接下来是加载配置文件并且启动MyBatis

public class CountryMapperTest{    private static SqlSessionFactory sqlSessionFactory;    @BeforeClass
    public static void init() {        try {            // 通过MyBatis自带的Resources工具来加载配置文件
            Reader reader = Resources.getResourceAsReader("config.xml");            // 通过SqlSessionFactoryBuilder()来构建sqlSessionFactory对象
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    @Test
    public void testSelectAll() {        // 打开一个session对象
        SqlSession sqlSession = sqlSessionFactory.openSession();        try {            // 通过session对象来获取mapper
            CountryMapper countryMapper = sqlSession.getMapper(CountryMapper.class);
            List<Country> countryList = countryMapper.selectAll();
            System.out.println(countryList);
        }finally {            // 记得关闭session
            sqlSession.close();
        }
    }
}

输出结果

[
    Country{id=1, countryName='中国', countryCode='CN'}, 
    Country{id=2, countryName='美国', countryCode='US'}, 
    Country{id=3, countryName='俄罗斯', countryCode='RU'}, 
    Country{id=4, countryName='英国', countryCode='GB'}, 
    Country{id=5, countryName='法国', countryCode='FR'}
]

至此，一个简单的实例就跑起来了

比较常用的几个配置

在config.xml中，有非常多的配置可以进行设置，具体可以参考官方的配置，其中有几个比较常用的罗列如下

<configuration>

    <!--
        指定实体类别名，
        在前面的配置中，如果我们的实体类存在于包中，那么在mapper文件中，需要使用的时候
        需要使用类的全限定名来指定，配置了别名之后，可以直接使用实体类名就行
        当然，实体类名也是需要全局唯一的，如果不唯一的话，就使用全限定类名来指定
    -->
    <typeAliases>
        <package name="domain"/>
    </typeAliases>

    <!--
        指定接口的位置，需要注意与<mapper resource="" />的区别
        需要注意的是，package是接口文件的包名，不是mapper.xml文件的位置
        不过一般打包的时候，会将mapper.xml与接口文件放在一起，所以本质也是一样
    -->
    <mappers>
        <package name="mapper"/>
    </mappers></configuration>

看到上面的例子，可能会觉得很奇怪，为什么通过接口文件就能进行操作，其实仔细分析也比较清楚，MyBatis通过扫描接口之后，通过动态代理技术生成对应的实例类，并且将其缓存起来。

MyBatis源码简单剖析

下面的内容是跟踪一个sqlSessionFactory的构建过程

SqlSessionFactory = new SqlSessionFactoryBuilder.build(reader)// 其中build过程如下public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);      return build(parser.parse());      // 省略其他操作}// parse过程如下public Configuration parse() {    // 省略其他操作
    parseConfiguration(parser.evalNode("/configuration"));    return configuration;
}// parseConfiguration过程如下private void parseConfiguration(XNode root) {    // 省略其他操作
    mapperElement(root.evalNode("mappers"));
}// mapperElement过程private void mapperElement(XNode parent) throws Exception {    if (parent != null) {      for (XNode child : parent.getChildren()) {        if ("package".equals(child.getName())) {          // 如果是 <mapper package name="" />则解析对应的包内的所有接口
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        }        // 省略其他操作
      }
    }
}// addMappers过程如下public void addMappers(String packageName) {
    mapperRegistry.addMappers(packageName);
}// addMapperspublic void addMappers(String packageName) {
    addMappers(packageName, Object.class);
}public void addMappers(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);    // 获取所有的class对象
    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();    for (Class<?> mapperClass : mapperSet) {
      addMapper(mapperClass);
    }
}// addMapperpublic <T> void addMapper(Class<T> type) {    // 检查是否是接口
    if (type.isInterface()) {      if (hasMapper(type)) {        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }        // 参见下面代码
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
    }
}// mapperRegistry定义public class MapperRegistry {  private final Configuration config;  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
}// mapperProxyFactorypublic class MapperProxyFactory<T> {  private final Class<T> mapperInterface;  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
}

到了这里配置文件解析以及mapper接口的查找完成，接下来就是获取以及实例化的过程了，也就是调用sqlSession.getMapper的过程了

sqlSession.getMapper(CountryMapper.class);// getMapper过程public <T> T getMapper(Class<T> type) {    return configuration.<T>getMapper(type, this);
}// 可以看到，其实就是从mapperRegistry中获取mapper了public <T> T getMapper(Class<T> type, SqlSession sqlSession) {    return mapperRegistry.getMapper(type, sqlSession);
}// 通过mapperProxyFactory来实例化public <T> T getMapper(Class<T> type, SqlSession sqlSession) {    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);    if (mapperProxyFactory == null) {      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }    try {      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}// mapperProxyFactory#newInstance过程public T newInstance(SqlSession sqlSession) {    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);    return newInstance(mapperProxy);
}// newInstance过程// 从这里就可以看到，其实就是通过JDK的动态代理来实例化接口对象protected T newInstance(MapperProxy<T> mapperProxy) {    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

到了这里，接口的实现就完成了，但是，分析的过程还没有结束，因为SQL语句和接口中的方法还没有对应上，继续分析

// 在JDK动态代理中，我们是需要传入一个InvocationHandler的实现类的，这里就是mapperProxy了public class MapperProxy<T> implements InvocationHandler, Serializable {
}// invoke方法public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    try {      // 如果是Object的方法，则直接调用
      if (Object.class.equals(method.getDeclaringClass())) {        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {        // 默认方法
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {      throw ExceptionUtil.unwrapThrowable(t);
    }    // 将方法缓存
    final MapperMethod mapperMethod = cachedMapperMethod(method);    // 调用接口的方法
    return mapperMethod.execute(sqlSession, args);
}// 缓存方法private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }    return mapperMethod;
}// MapperMethodpublic class MapperMethod {    private final SqlCommand command;    private final MethodSignature method;
}// sqlCommand，主要就是sql的绑定啦public static class SqlCommand {    private final String name;    private final SqlCommandType type;    public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {      final String methodName = method.getName();      final Class<?> declaringClass = method.getDeclaringClass();
      MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
          configuration);      if (ms == null) {        if (method.getAnnotation(Flush.class) != null) {
          name = null;
          type = SqlCommandType.FLUSH;
        }
      } else {
        name = ms.getId();
        type = ms.getSqlCommandType();
      }
    }
}// 解析mapper语句private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
        Class<?> declaringClass, Configuration configuration) {
      String statementId = mapperInterface.getName() + "." + methodName;      if (configuration.hasStatement(statementId)) {        return configuration.getMappedStatement(statementId);
      } else if (mapperInterface.equals(declaringClass)) {        return null;
      }      for (Class<?> superInterface : mapperInterface.getInterfaces()) {        if (declaringClass.isAssignableFrom(superInterface)) {          // 递归解析
          MappedStatement ms = resolveMappedStatement(superInterface, methodName,
              declaringClass, configuration);          if (ms != null) {            return ms;
          }
        }
      }      return null;
    }
}// execute方法public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;    // 根据SQL中的类型来执行不同的操作
    switch (command.getType()) {      // 其他的操作
      
      // select操作
      case SELECT:        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }        break;
    }    return result;
}

作者：颜洛滨
链接：https://www.jianshu.com/p/c115093326d0