基础框架 Mybatis源码分析

Bertha 。 2022-12-31 02:23 176阅读 0赞

## 基础框架 Mybatis源码分析 ##

### 一、主要步骤 ###

源码分析主要从以下几个步骤代码跟进
    1.读取配置文件
    2.创建SqlSessionFactory工厂
    3.使用工厂生产SQLSession对象
    4.使用SQLSession创建Dao接口的代理对象
    5.使用代理对象执行方法

### 三、代码步骤 ###

/** * myBatis测试类 * * @author zrj * @date 2020/12/23 * @since V1.0 **/
    public class MyBatisTest { 
    
      /** * mybatis测试 * 基于配置文件,查询操作 */
      @Test
      public void myBatisFindAllTest() throws IOException { 
        // 1.读取配置文件
        InputStream in = Resources.getResourceAsStream( "SqlMapConfig.xml" );
    
        // 2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build( in );
    
        // 3.使用工厂生产SQLSession对象
        // 设置自动提交
        boolean autoCommit = true;
        SqlSession session = factory.openSession( autoCommit );
    
        // 4.使用SQLSession创建Dao接口的代理对象
        UserDao userDao = session.getMapper( UserDao.class );
    
        // 5.使用代理对象执行方法
        List<User> userList = userDao.findAll();
        userList.forEach( System.out::println );
        System.out.println( "查询成功" );
    
        // 设置自动提交后就不需要手动提交事务了，否则默认关闭，需要手动提交，而且只有更新删除插入需要，查询不需要。
        //session.commit();
    
        // 6.释放资源
        session.close();
        in.close();
      }
    
    }

### 三、依次跟进分析 ###

1.  读取配置文件

// 这里只做配置文件读取
      InputStream in = Resources.getResourceAsStream( "SqlMapConfig.xml" );

1.  创建SqlSessionFactory工厂

// 创建SqlSessionFactory工厂，这个比较重要，涉及初始化配置对象
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build( in );
    
      /** * 1.通过SqlMapConfig.xml文件流构建SqlSessionFactory工厂 */
      public SqlSessionFactory build(InputStream inputStream) { 
        return build(inputStream, null, null);
      }
      public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
        try { 
          // 2.构建XMLConfigBuilder对象
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          // 3.build返回SqlSessionFactory，
          // parser.parse()创建Configuration对象，主要就在这里将xml解析后对于属性值set到Configuration对象
          return build(parser.parse());
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally { 
          ErrorContext.instance().reset();
          try { 
            inputStream.close();
          } catch (IOException e) { 
            // Intentionally ignore. Prefer previous error.
          }
        }
      }

*  parser.parse()具体解析xml赋值到Configuration对象

/** * 解析xml赋值到Configuration对象 */
      public Configuration parse() { 
        if (parsed) { 
          throw new BuilderException( "Each XMLConfigBuilder can only be used once." );
        }
        parsed = true;
        //解析xml配置文件SqlMapConfig根节点Configuration信息
        parseConfiguration( parser.evalNode( "/configuration" ) );
        return configuration;
      }
    
      /** * 各个节点具体解析赋值Configuration对象 */
      private void parseConfiguration(XNode root) { 
        try { 
          // issue #117 read properties first
          propertiesElement( root.evalNode( "properties" ) );
          Properties settings = settingsAsProperties( root.evalNode( "settings" ) );
          loadCustomVfs( settings );
          loadCustomLogImpl( settings );
          typeAliasesElement( root.evalNode( "typeAliases" ) );
          pluginElement( root.evalNode( "plugins" ) );
          objectFactoryElement( root.evalNode( "objectFactory" ) );
          objectWrapperFactoryElement( root.evalNode( "objectWrapperFactory" ) );
          reflectorFactoryElement( root.evalNode( "reflectorFactory" ) );
          settingsElement( settings );
          // read it after objectFactory and objectWrapperFactory issue #631
          environmentsElement( root.evalNode( "environments" ) );
          databaseIdProviderElement( root.evalNode( "databaseIdProvider" ) );
          typeHandlerElement( root.evalNode( "typeHandlers" ) );
          mapperElement( root.evalNode( "mappers" ) );
        } catch (Exception e) { 
          throw new BuilderException( "Error parsing SQL Mapper Configuration. Cause: " + e, e );
        }
      }

*  通过Configuration对象构建SqlSessionFactory

/** * 通过Configuration对象构建SqlSessionFactory */
      public SqlSessionFactory build(Configuration config) { 
        return new DefaultSqlSessionFactory(config);
      }

1.  使用工厂生产SQLSession对象

// 使用工厂生产SQLSession对象，设置自动提交，这里不开启默认是关闭状态。
     boolean autoCommit = true;
     SqlSession session = factory.openSession( autoCommit );
    
      /** * 事务autoCommit默认fase关闭状态 */
      @Override
      public SqlSession openSession() { 
        return openSessionFromDataSource( configuration.getDefaultExecutorType(), null, false );
      }
    
      @Override
      public SqlSession openSession(boolean autoCommit) { 
        return openSessionFromDataSource( configuration.getDefaultExecutorType(), null, autoCommit );
      }

1.  使用SQLSession创建Dao接口的代理对象

// 使用SQLSession创建Dao接口的代理对象
    UserDao userDao = session.getMapper( UserDao.class );
      
    /** * DefaultSqlSession获取代理对象 */
    @Override
    public <T> T getMapper(Class<T> type) { 
      return configuration.getMapper(type, this);
    }
    
      @SuppressWarnings("unchecked")
      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 { 
          // MapperRegistry 通过动态代理的方式获取代理对象
          return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception e) { 
          throw new BindingException("Error getting mapper instance. Cause: " + e, e);
        }
      }
      @SuppressWarnings("unchecked")
      protected T newInstance(MapperProxy<T> mapperProxy) { 
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {  mapperInterface }, mapperProxy);
      }
    
    // 返回MapperProxy代理对象
      public T newInstance(SqlSession sqlSession) { 
        final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }

1.  通过代理对象调用执行方法封装结果集  
    通过MapperProxy执行invoke方法

@Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        try { 
          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);
        }
      }
      
        @Override
        public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable { 
        // 调用执行器
          return mapperMethod.execute(sqlSession, args);
        }
    
    
      /** * 通过标签判断执行类型，封装结果集 */
      public Object execute(SqlSession sqlSession, Object[] args) { 
        Object result;
        switch (command.getType()) { 
          case INSERT: { 
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
          case UPDATE: { 
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
          }
          case DELETE: { 
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
          }
          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);
              if (method.returnsOptional()
                  && (result == null || !method.getReturnType().equals(result.getClass()))) { 
                result = Optional.ofNullable(result);
              }
            }
            break;
          case FLUSH:
            result = sqlSession.flushStatements();
            break;
          default:
            throw new BindingException("Unknown execution method for: " + command.getName());
        }
        if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { 
          throw new BindingException("Mapper method '" + command.getName()
              + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
        }
        return result;
      }