解析 MyBatis 中 Mapper 生效的来龙去脉

<!-- https: //mvnrepository.com/artifact/org.mybatis/mybatis -->

<dependency>

     <groupId>org.mybatis</groupId>

     <artifactId>mybatis</artifactId>

     <version> 3.5 . 6 </version>

</dependency>

<dependency>

     <groupId>mysql</groupId>

     <artifactId>mysql-connector-java</artifactId>

     <version> 5.1 . 49 </version>

</dependency>

<dependency>

     <groupId>junit</groupId>

     <artifactId>junit</artifactId>

     <version> 4.12 </version>

</dependency>

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql: //127.0.0.1:3306/mybatistest?useUnicode=true&amp;characterEncoding=utf-8

jdbc.username=root

jdbc.password=root

<?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 resource= "jdbc.properties" ></properties>

     <!-- 配置setting属性-->

     <settings>

         <!-- 开启了一个驼峰命名规则-->

         <setting name= "mapUnderscoreToCamelCase" value= "true" />

         <!-- 日志-->

         <setting name= "logImpl" value= "STDOUT_LOGGING" ></setting>

     </settings>

     <!-- 配置数据库-->

     <environments default = "development" >

         <environment id= "development" >

             <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>

     <!--  mappers中注册我们所有写的dao接口的实现（映射）文件-->

     <mappers>

         <mapper resource= "/.IUserMapper.xml" />

         <!-- 如果映射文件有十几百个的话，可以用下面的全局注册

             < package name= "文件所在包路径" ></ package >

             < package name= "cn.liuliang.Dao" ></ package >

         -->

     </mappers>

</configuration>

public interface IUserMapper {

     /**

      * 查询所有用户

      * @return

      */

      List<User> findAll();

}

public class MyBatisTest {

     @Test

     public void test01() throws IOException {

         // 读取配置文件

         InputStream in= Resources.getResourceAsStream( "MyBatisConfig.xml" );

         // 创建sqlSessionFactory

         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);

         // 获得会话

         SqlSession session=sqlSessionFactory.openSession();

         // 得到代理

         IUserMapper iUserMapper =session.getMapper(IUserMapper. class );

         // 查询数据库

         List<User> userList= iUserMapper.findAll();

         for (User user : userList) {

             System.out.println(user);

         }

     }

}

// 读取配置文件

InputStream in= Resources.getResourceAsStream( "MyBatisConfig.xml" );

// 创建sqlSessionFactory

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {

     // ...

     // 根据文件流，创建 XMLConfigBuilder 对象

     XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);

     // 先解析 配置文件，然后构建出 SqlSessionFactory对象

     return build(parser.parse());

     // ...

}

public SqlSessionFactory build(Configuration config) {

     return new DefaultSqlSessionFactory(config);

}

// 获得会话

SqlSession session=sqlSessionFactory.openSession();

public SqlSession openSession() {

   return openSessionFromDataSource(configuration.getDefaultExecutorType(), null , false );

}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {

     Transaction tx = null ;

     try {

         // 根据配置文件 configuration 获取对应的会话环境（包括事物，数据源）

         final Environment environment = configuration.getEnvironment();

         // 获取事物工厂

         final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);

         // 根据数据源，配置事物，autoCommit：是否自动提交事物

         tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);

         // 根据配置获取执行器（最终都是它执行对应的数据库操作）

         final Executor executor = configuration.newExecutor(tx, execType);

         // 准备好上面的信息之后，都封装到默认会话对象中返回出去

         return new DefaultSqlSession(configuration, executor, autoCommit);

     } catch (Exception e) {

         closeTransaction(tx); // may have fetched a connection so lets call close()

         throw ExceptionFactory.wrapException( "Error opening session.  Cause: " + e, e);

     } finally {

         ErrorContext.instance().reset();

     }

}

// 得到代理

IUserMapper iUserMapper =session.getMapper(IUserMapper. class );

public <T> T getMapper(Class<T> type) {

     // 根据配置类，获取 Mapper

     return configuration.getMapper(type, this );

}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {

     // 从 mapperRegistry 中获取具体 Mapper

     return mapperRegistry.getMapper(type, sqlSession);

}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {

     // knownMappers，一个Map，存放 Mapper 代理工厂

     // 在初始化的时候根据配置文件已经将所有配置的 Mapper 接口注册到此了

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

     }

}

public T newInstance(SqlSession sqlSession) {

     // 根据 SqlSession 和 Mapper 接口生成代理对象

     final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);

     // 真正代理，如下

     return newInstance(mapperProxy);

}

// 下面就是根据 JDK 原生 API 进行代理了，由此返回代理对象给用户使用

protected T newInstance(MapperProxy<T> mapperProxy) {

     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);

}

// 查询数据库

List<User> userList= iUserMapper.findAll();

for (User user : userList) {

     System.out.println(user);

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

     try {

         // 方法的类为 object 直接通过原始 JDK 去执行

         if (Object. class .equals(method.getDeclaringClass())) {

             return method.invoke( this , args);

         } else {

             // 根据方法，获得方法的执行器后再执行代理方法

             return cachedInvoker(method).invoke(proxy, method, args, sqlSession);

         }

     } catch (Throwable t) {

         throw ExceptionUtil.unwrapThrowable(t);

     }

}

private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {

     try {

         // 先查缓存，有就返回，没有就创建

         MapperMethodInvoker invoker = methodCache.get(method);

         if (invoker != null ) {

             return invoker;

         }

         return methodCache.computeIfAbsent(method, m -> {

             // ...

             // 返回 PlainMethodInvoker 类型的 Mapper 方法执行器

             return new PlainMethodInvoker( new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));

             // ...

         });

     } catch (RuntimeException re) {

         Throwable cause = re.getCause();

         throw cause == null ? re : cause;

     }

}

public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {

     // 调用 mapperMethod 对象的 execute 方法去真正执行了

     return mapperMethod.execute(sqlSession, args);

}

public Object execute(SqlSession sqlSession, Object[] args) {

     // 这里面内容比较多，我简单分析一下

     // 1）封装参数

     // 2）根据对应的执行类型（INSERT，UPDATE，DELETE，SELECT），执行对应的方法

     // 3）根据参数，执行类型封装对应的 sql

     // 4）操作原生 JDBC API 执行数据库操作

     // 5）封装结果集，返回出去

}