[Java] Mybatis原理及源码分析

• 在SQL模板绑定用户参入实参的场景中，将Java类型转换成JDBC类型
  
• 在结果集中，将JDBC类型转换成Java类型。
  

@Bean 
@ConditionalOnMissingBean 
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception { 
  SqlSessionFactoryBean factory = new SqlSessionFactoryBean(); 
  factory.setDataSource(dataSource); 
  factory.setVfs(SpringBootVFS.class); 
  if (StringUtils.hasText(this.properties.getConfigLocation())) { 
  factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation())); 
  } 
  Configuration configuration = this.properties.getConfiguration(); 
  if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) { 
  configuration = new Configuration(); 
  } 
  if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) { 
  for (ConfigurationCustomizer customizer : this.configurationCustomizers) { 
    customizer.customize(configuration); 
  } 
  } 
  factory.setConfiguration(configuration); 
  if (this.properties.getConfigurationProperties() != null) { 
  factory.setConfigurationProperties(this.properties.getConfigurationProperties()); 
  } 
  if (!ObjectUtils.isEmpty(this.interceptors)) { 
  factory.setPlugins(this.interceptors); 
  } 
  if (this.databaseIdProvider != null) { 
  factory.setDatabaseIdProvider(this.databaseIdProvider); 
  } 
  if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) { 
  factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage()); 
  } 
  if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) { 
  factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage()); 
  } 
  if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) { 
  factory.setMapperLocations(this.properties.resolveMapperLocations()); 
  } 
 
  return factory.getObject(); 
}

@Override 
public SqlSessionFactory getObject() throws Exception { 
  if (this.sqlSessionFactory == null) { 
  afterPropertiesSet(); 
  } 
 
  return this.sqlSessionFactory; 
}

@Override 
public void afterPropertiesSet() throws Exception { 
  notNull(dataSource, "Property 'dataSource' is required"); 
  notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required"); 
  state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null), 
      "Property 'configuration' and 'configLocation' can not specified with together"); 
 
  this.sqlSessionFactory = buildSqlSessionFactory(); 
}

public SqlSessionFactory build(Configuration config) { 
  return new DefaultSqlSessionFactory(config); 
  }

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) { 
   this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType()); 
 }

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, 
  PersistenceExceptionTranslator exceptionTranslator) { 
 
  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required"); 
  notNull(executorType, "Property 'executorType' is required"); 
 
  this.sqlSessionFactory = sqlSessionFactory; 
  this.executorType = executorType; 
  this.exceptionTranslator = exceptionTranslator; 
  this.sqlSessionProxy = (SqlSession) newProxyInstance( 
    SqlSessionFactory.class.getClassLoader(), 
    new Class[] { SqlSession.class }, 
    new SqlSessionInterceptor()); 
}

@Override 
 public T getObject() throws Exception { 
   return getSqlSession().getMapper(this.mapperInterface); 
 }

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

@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 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; 
  }

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

@Override 
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { 
  Statement stmt = null; 
  try { 
  Configuration configuration = ms.getConfiguration(); 
  StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); 
  stmt = prepareStatement(handler, ms.getStatementLog()); 
  return handler.<E>query(stmt, resultHandler); 
  } finally { 
  closeStatement(stmt); 
  } 
}

@Override 
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { 
  String sql = boundSql.getSql(); 
  statement.execute(sql); 
  return resultSetHandler.<E>handleResultSets(statement); 
}