Mybatis工作机制源码分析—初始化

最新推荐文章于 2024-05-29 16:16:20 发布
最新推荐文章于 2024-05-29 16:16:20 发布
阅读量850 收藏
点赞数
分类专栏： mybatis 文章标签： mybatis 源码分析 初始化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Architect0719/article/details/53998533
版权

       本文以Spring集成Mybatis的形式，在启动工程过程中，Spring容器会实例化SqlSessionFactoryBean，来讲解Mybatis是如何进行初始化工作。

Spring配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> 
 
<beans xmlns="http://www.springframework.org/schema/beans"
  	   	xmlns:aop="http://www.springframework.org/schema/aop"
	   	xmlns:tx="http://www.springframework.org/schema/tx"
  	   	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   	xmlns:context="http://www.springframework.org/schema/context"  
	   	xmlns:p="http://www.springframework.org/schema/p"
  	   	xsi:schemaLocation="
          	http://www.springframework.org/schema/beans    
       		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           	http://www.springframework.org/schema/tx      
     		http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
           	http://www.springframework.org/schema/context
           	http://www.springframework.org/schema/context/spring-context-3.0.xsd
           	http://www.springframework.org/schema/aop
           	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           	http://www.springframework.org/schema/jdbc 
           	http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd ">
           	
	<context:property-placeholder location="classpath:META-INF/dbproperties/*.properties" />

	<!-- 扫描注解文件  -->
	<context:component-scan base-package="org.test" />	
	
	<!-- 配置数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
	    <property name="driverClassName" value="${db.driver}"></property>
 		<property name="url" value="${db.url}" />
        <property name="username" value="${db.userName}" />
        <property name="password" value="${db.password}" />
	    <property name="maxTotal" value="10"/>
     	<property name="initialSize" value="5"/>
    	<property name="defaultReadOnly" value="false"/>
    </bean>
	
	
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:META-INF/mybatis/config/mybatis-config.xml"></property>
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations" value="${sqlMapperLocations}" />
	</bean>
	
	
	  <!-- 配置sqlSessionTemplate --> 
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">  
        <constructor-arg index="0" ref="sqlSessionFactory" />  
    </bean>

	<!-- 事务管理 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 事务注解支持 -->
	<tx:annotation-driven transaction-manager="transactionManager" />
	
</beans>

SqlSessionFactoryBean与SqlSessionTemplate

       SqlSessionFactoryBean的主要工作为创建SqlSessionFactory实例；SqlSessionFactory再基于connection或DataSource来创建SqlSesion，SqlSesion可理解为一次sql会话，可进行sql语句形式的增删改查以及事务提交回滚等；SqlSessionTemplate则面向Mybatis对外的 DAO的使用者，通过以SqlSesion代理的形式，对外提供基于Spring事务管理的SqlSesion功能，SqlSessionTemplate是线程安全的，可多个DAO共用。

        SqlSessionFactoryBean部分源码：

/** SqlSessionFactoryBean.java */
// 主要工作：创建SqlSessionFactory，在Spring容器中可通过依赖注入的形式被多个DAO共用
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {

  private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);

  private Resource configLocation; // MyBatis config配置文件

  private Resource[] mapperLocations; // MyBatis mapper配置文件

  private DataSource dataSource; // 数据库源（一般带连接池）

  private TransactionFactory transactionFactory;

  private Properties configurationProperties;

  private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

  private SqlSessionFactory sqlSessionFactory; // sqlSession Factory，用来管理sqlSession
  
  ...
  
  // SqlSessionFactoryBean为FactoryBean，在Spring配置文件中直接获取，则获取sqlSessionFactory
  public SqlSessionFactory getObject() throws Exception {
    if (this.sqlSessionFactory == null) {
      afterPropertiesSet();
    }

    return this.sqlSessionFactory;
  }
  
  // SqlSessionFactoryBean为InitializingBean，SqlSessionFactoryBean实例化过程中，主要初始化工作在afterPropertiesSet
  public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");

    this.sqlSessionFactory = buildSqlSessionFactory();
  }
  
  // MyBatis初始化的核心工作，主要做两件事情：
  // 1）解析Mybatis config、mapper配置文件；2）用解析结果configuration创建DefaultSqlSessionFactory实例
  protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'configLocation' not specified, using default MyBatis Configuration");
      }
      configuration = new Configuration();
      configuration.setVariables(this.configurationProperties);
    }

    if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }

    if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }

    if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeAliasPackageArray) {
        configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
        }
      }
    }

    if (!isEmpty(this.typeAliases)) {
      for (Class<?> typeAlias : this.typeAliases) {
        configuration.getTypeAliasRegistry().registerAlias(typeAlias);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type alias: '" + typeAlias + "'");
        }
      }
    }

    if (!isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins) {
        configuration.addInterceptor(plugin);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered plugin: '" + plugin + "'");
        }
      }
    }

    if (hasLength(this.typeHandlersPackage)) {
      String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeHandlersPackageArray) {
        configuration.getTypeHandlerRegistry().register(packageToScan);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
        }
      }
    }

    if (!isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers) {
        configuration.getTypeHandlerRegistry().register(typeHandler);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type handler: '" + typeHandler + "'");
        }
      }
    }

    if (xmlConfigBuilder != null) {
      try {
        xmlConfigBuilder.parse();

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
        }
      } catch (Exception ex) {
        throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
      } finally {
        ErrorContext.instance().reset();
      }
    }

    if (this.transactionFactory == null) {
      this.transactionFactory = new SpringManagedTransactionFactory();
    }

    configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

    if (this.databaseIdProvider != null) {
      try {
        configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      } catch (SQLException e) {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }

    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }

        try {
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              configuration, mapperLocation.toString(), configuration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
        }
      }
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
      }
    }

    return this.sqlSessionFactoryBuilder.build(configuration);
  }
  
  // SqlSessionFactoryBean为ApplicationListener，响应ApplicationEvent事件
  public void onApplicationEvent(ApplicationEvent event) {
    if (failFast && event instanceof ContextRefreshedEvent) {
      // fail-fast -> check all statements are completed
      this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
    }
  }
  
  ...
}

        SqlSessionFactory接口：

/** SqlSessionFactory.java */
// SqlSessionFactory基于connection或DataSource来创建SqlSesion
public interface SqlSessionFactory {

  SqlSession openSession();

  SqlSession openSession(boolean autoCommit);
  SqlSession openSession(Connection connection);
  SqlSession openSession(TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType);
  SqlSession openSession(ExecutorType execType, boolean autoCommit);
  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
  SqlSession openSession(ExecutorType execType, Connection connection);

  Configuration getConfiguration();

}

       SqlSesion接口概览：


       SqlSessionTemplate部分源码：

/** SqlSessionTemplate.java */
// SqlSessionTemplate以SqlSesion代理的形式，对外提供基于Spring事务管理的SqlSesion功能；
// SqlSessionTemplate是线程安全的，可多个DAO共用
public class SqlSessionTemplate implements SqlSession {

  private final SqlSessionFactory sqlSessionFactory; // 借助sqlSessionFactory来创建SqlSessions

  private final ExecutorType executorType;

  private final SqlSession sqlSessionProxy; // 对外的sqlSession代理，对使用者是透明的

  private final PersistenceExceptionTranslator exceptionTranslator;
  
  ...
  
  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;
	// JDK动态代理
    this.sqlSessionProxy = (SqlSession) newProxyInstance(
        SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class },
        new SqlSessionInterceptor());
  }
  
  private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(
          SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType,
          SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args); // 代理方法调用，实际调用的是sqlSessionFactory创建的sqlSession
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

  ...
}

整体流程

         Mybatis初始化核心工作在SqlSessionFactoryBean的实例化，其为FactoryBean且实现InitializingBean接口：

public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");

    this.sqlSessionFactory = buildSqlSessionFactory();
  }

buildSqlSessionFactory()则进行初始化工作。

时序图


相关类结构图


相关源码

/** SqlSessionFactoryBean.java */
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

	Configuration configuration;

	XMLConfigBuilder xmlConfigBuilder = null;
	if (this.configLocation != null) {
	  // 构建xmlConfigBuilder，核心工作为构造XPathParser：完成Mybatis的配置文件inputStream到Document对象的转化；设置xpath sax解析工具
	  xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
	  // 解析结果configuration
	  configuration = xmlConfigBuilder.getConfiguration();
	} else {
	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("Property 'configLocation' not specified, using default MyBatis Configuration");
	  }
	  configuration = new Configuration();
	  configuration.setVariables(this.configurationProperties);
	}

	// configuration设置SqlSessionFactoryBean依赖注入的objectFactory、objectWrapperFactory、typeAliasesPackage
	// typeAliases、plugins、typeHandlersPackage、typeHandlers实例到相应的属性
	if (this.objectFactory != null) {
	  configuration.setObjectFactory(this.objectFactory);
	}

	if (this.objectWrapperFactory != null) {
	  configuration.setObjectWrapperFactory(this.objectWrapperFactory);
	}

	if (hasLength(this.typeAliasesPackage)) {
	  String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
		  ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	  for (String packageToScan : typeAliasPackageArray) {
		configuration.getTypeAliasRegistry().registerAliases(packageToScan,
				typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
		}
	  }
	}

	if (!isEmpty(this.typeAliases)) {
	  for (Class<?> typeAlias : this.typeAliases) {
		configuration.getTypeAliasRegistry().registerAlias(typeAlias);
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Registered type alias: '" + typeAlias + "'");
		}
	  }
	}

	if (!isEmpty(this.plugins)) {
	  for (Interceptor plugin : this.plugins) {
		configuration.addInterceptor(plugin);
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Registered plugin: '" + plugin + "'");
		}
	  }
	}

	if (hasLength(this.typeHandlersPackage)) {
	  String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
		  ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	  for (String packageToScan : typeHandlersPackageArray) {
		configuration.getTypeHandlerRegistry().register(packageToScan);
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
		}
	  }
	}

	if (!isEmpty(this.typeHandlers)) {
	  for (TypeHandler<?> typeHandler : this.typeHandlers) {
		configuration.getTypeHandlerRegistry().register(typeHandler);
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Registered type handler: '" + typeHandler + "'");
		}
	  }
	}

	if (xmlConfigBuilder != null) {
	  try {
		// 解析MyBatis config配置文件
		xmlConfigBuilder.parse();

		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
		}
	  } catch (Exception ex) {
		throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
	  } finally {
		ErrorContext.instance().reset();
	  }
	}

	// configuration设置environment、databaseId
	if (this.transactionFactory == null) {
	  // 采用Spring管理的TransactionFactory
	  this.transactionFactory = new SpringManagedTransactionFactory();
	}

	// 覆盖Mybatis config配置文件中配置的Environment，主要涉及SpringManagedTransactionFactory
	configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

	if (this.databaseIdProvider != null) {
	  try {
		configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
	  } catch (SQLException e) {
		throw new NestedIOException("Failed getting a databaseId", e);
	  }
	}

	if (!isEmpty(this.mapperLocations)) {
	  for (Resource mapperLocation : this.mapperLocations) {
		if (mapperLocation == null) {
		  continue;
		}

		try {
		  // 构造XMLMapperBuilder
		  XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
			  configuration, mapperLocation.toString(), configuration.getSqlFragments());
		  // 解析MyBatis mapper配置文件
		  xmlMapperBuilder.parse();
		} catch (Exception e) {
		  throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
		} finally {
		  ErrorContext.instance().reset();
		}

		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
		}
	  }
	} else {
	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
	  }
	}

	// 返回DefaultSqlSessionFactory
	return this.sqlSessionFactoryBuilder.build(configuration);
}

详细流程
构造XMLConfigBuilder

/** XMLConfigBuilder.java */
// XMLConfigBuilder构造器
public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
	// XMLMapperEntityResolver用于加载"org/apache/ibatis/builder/xml/mybatis-3-config.dtd"、
	// "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd"为InputSource，用于sax解析Mybatis的config、mapper配置文件
	// MyBatis采用dtd模式来解析其配置文件
	this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
}

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
	super(new Configuration());
	ErrorContext.instance().resource("SQL Mapper Configuration");
	this.configuration.setVariables(props);
	this.parsed = false;
	this.environment = environment;
	this.parser = parser;
}

/** XPathParser.java */
// XPathParser构造函数，完成Mybatis的配置文件inputStream到Document对象的转化
public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
	commonConstructor(validation, variables, entityResolver);
	this.document = createDocument(new InputSource(inputStream));
}

// 设置解析工具
private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
	this.validation = validation;
	this.entityResolver = entityResolver;
	this.variables = variables;
	XPathFactory factory = XPathFactory.newInstance();
	// 借助javax.xml.xpath.XPath辅助XPathParser解析
	this.xpath = factory.newXPath();
}

// 将Mybatis的配置文件inputStream转化为Document对象
private Document createDocument(InputSource inputSource) {
	// important: this must only be called AFTER common constructor
	try {
	  // 利用javax.xml.parsers.DocumentBuilderFactory来创建DocumentBuilder
	  DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	  factory.setValidating(validation);

	  factory.setNamespaceAware(false);
	  factory.setIgnoringComments(true);
	  factory.setIgnoringElementContentWhitespace(false);
	  factory.setCoalescing(false);
	  factory.setExpandEntityReferences(true);

	  DocumentBuilder builder = factory.newDocumentBuilder();
	  // 设置javax.xml.parsers.DocumentBuilder
	  builder.setEntityResolver(entityResolver);
	  builder.setErrorHandler(new ErrorHandler() {
		@Override
		public void error(SAXParseException exception) throws SAXException {
		  throw exception;
		}

		@Override
		public void fatalError(SAXParseException exception) throws SAXException {
		  throw exception;
		}

		@Override
		public void warning(SAXParseException exception) throws SAXException {
		}
	  });
	  // inputSource解析为Document对象
	  return builder.parse(inputSource);
	} catch (Exception e) {
	  throw new BuilderException("Error creating document instance.  Cause: " + e, e);
	}
}

Mybatis 配置文件sax解析

详见：Mybatis工作机制源码分析—初始化—sax解析

Mybatis config配置文件解析

详见：Mybatis工作机制源码分析—初始化—config配置文件解析

Mybatis mapper配置文件解析

详见：Mybatis工作机制源码分析—初始化—mapper配置文件解析

Architect0719
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【MyBatis源码分析】configuration初始化机制详解
温柔常伴
01-08 1612
configuration加载解析对于任何框架而言，在使用前都要进行一系列的初始化，MyBatis也不例外。本章将通过以下几点详细介绍  MyBatis的初始化过程。  1. MyBatis的初始化做了什么  2. MyBatis基于XML配置文件创建Configuration对象的过程  3. 涉及到的相关设计模式一、 MyBatis的初始化做了什么任何框架的初始化，无非是加载自己运行时所需要的...
Mybatis工作机制源码分析—初始化—config配置文件解析
探索java技术、web技术
01-05 702
本文通过源码分析的形式讲解Mybatis config配置文件是如何解析的。 时序图 相关源码 /** XMLConfigBuilder解析 */ /** XMLConfigBuilder.java */ public Configuration parse() { if (parsed) { throw new BuilderException("Each XMLConfi
Mybatis工作机制源码分析—初始化—sax解析
探索java技术、web技术
01-05 800
本文以解析Mybatis config配置文件中"/configuration"元素为例进行说明Mybatis是如何进行sax解析工作的。 Mybatis配置文件解析流程图 时序图 相关源码 /** XMLConfigBuilder.java */ // 以解析Mybatis config配置文件"/configuration"元素为例说明sax解析机制： parser.e
Mybatis工作机制源码分析—初始化—mapper配置文件解析
探索java技术、web技术
01-05 1598
本文以源码分析的形式讲解Mybatis是如何进行mapper配置文件的解析工作的。 时序图 相关源码 /** XMLMapperBuilder.java */ // 构造XMLMapperBuilder public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resour
Mybatis源码分析（三）SqlSessionFactoryl的初始化
长安不及十里的博客
01-11 3392
文章主要介绍sqlSessionFactory是如何被创建的，主要是对我们配置的各个节点的解析并设置到Configuration的属性之中，我们可以看到Mybatis的设计模式的运用一以及个功能模块的流程上应该符合单一职责，而每一个具体的实现又得具备迪米特法则，这样实现出来的功能才能具有良好的扩展性。
Mybatis源码分析（二）Mybatis-config.xml的初始化
长安不及十里的博客
01-11 3552
本篇文件介绍mybatis-config.xml的文件解析，主要通过阅读源码和断点调试的方式来理解解析过程，这个过程会学到类的加载机制，双亲委派机制，VFS等等知识 主要通过类的加载机制将我们编写的配置文件转换成流数据，以便SqlSessionFactoryBuilder构建SqlSession对象
Mybatis工作机制源码分析—一次insert请求处理流程
探索java技术、web技术
01-15 1927
本文从源码分析的角度分析Mybatis一次insert请求处理流程。 insert整体处理流程 时序图 相关源码 /** SqlSessionTemplate.java */ public int insert(String statement, Object parameter) { return this.sqlSessionProxy.insert(statement, p
【MyBatis-Plus 源码分析】核心组件、工作流程、SQL执行过程、源码分析
最新发布
好好学习日记
05-29 1354
MyBatis-Plus 是一个增强版的 MyBatis 框架，它在 MyBatis 的基础上增加了许多实用的功能，例如乐观锁插件、字段自动填充、分页插件、条件构造器和 SQL 注入器等。MyBatis-Plus 允许开发者无需编写 XML 文件，直接通过继承 BaseMapper 接口的类来完成数据库操作。MyBatis-Plus 作为 MyBatis 的增强框架，其工作流程在继承 MyBatis 的基础上进行了优化和扩展。继承 BaseMapper。
Mybatis-Spring源码分析(四) Mybatis的初始化
Smallc0de的博客
10-15 499
当我们使用Mybatis调用Mapper接口中的方法的时候，可以确定Mybatis已经把SQL语句给拿到了，否则后续的步骤就无法进行了。那么Mybatis是在什么时候初始化Mapper并且拿到其中的内容的呢？
Mybatis源码分析.pdf
08-30
MyBatis是一款优秀的持久层框架，它的源码分析对于深入理解其工作原理和优化数据库操作至关重要。MyBatis的核心设计理念是简化SQL操作，通过XML或注解的方式将SQL与Java代码分离，同时提供强大的动态SQL功能。 首先...
Mybatis:Mybatis源码分析
03-24
Mybatis 源码分析是理解其内部工作原理的重要途径，这对于优化数据库访问性能、解决实际问题以及定制化开发都有着极大的帮助。 1. **SqlSessionFactoryBuilder**：Mybatis的初始化始于`SqlSessionFactoryBuilder`，...
java-ORM框架Mybatis源码分析
02-27
首先，MyBatis的初始化过程始于`SqlSessionFactoryBuilder`，它负责读取配置文件，构建`SqlSessionFactory`。配置文件通常包含数据源信息、Mapper XML文件的位置以及MyBatis全局设置。`SqlSessionFactory`是整个...
Mybatis源码分析.md
08-11
在MyBatis框架中，创建`SQLSessionFactory`是初始化整个框架的重要步骤之一。这一过程涉及到了配置文件的读取与解析，以及如何构建出可以用于创建`SqlSession`的工厂。 ##### 创建流程 1. **读取配置文件**： ```...
Mybatis源码分析-上课笔记1
08-03
SqlSessionFactory是线程安全的，通常在应用启动时初始化一次。可以通过SqlSessionFactoryBuilder类的getInstance方法获取，该方法保证了单例模式。 3. **SqlSession**：SqlSession是用户与MyBatis进行交互的接口，...
Mybatis工作机制源码分析—SqlSessionUtils.getSqlSession工作机制
探索java技术、web技术
05-23 5372
在调用SqlSessionTemplate进行dao层操作时，其会将工作委托给sqlSessionProxy属性进行，而sqlSessionProxy在进行相关method调用时，用到了JDK动态代理机制，首先SqlSessionUtils.getSqlSession获取sqlSession，本文主要以源码的形式阐述其工作机制。 SqlSessionTemplate.SqlSessionInte
mybatis与spring集成中SqlSessionFactory创建流程
探索java技术、web技术
09-17 2996
Mybatis作为优秀且广泛使用的轻量级持久层框架经常与Spring集成一起使用，集成过程中sqlSessionFactory的创建流程是什么样的呢？本文结合mybatis、mybatis-spring源码以及UML时序图的方式阐述如何进行： 以下为Mybatis与Spring集成的部分配置，主要是涉及SqlSessionFactory bean：
Mybatis工作机制源码分析—一次select请求处理流程
探索java技术、web技术
01-15 1323
本文从源码分析的角度分析Mybatis一次select请求处理流程。 select整体处理流程 时序图 DefaultSqlSession.selectOne工作流程 时序图 DynamicSqlSource构建BoundSql工作流程 相关源码 /** DefaultSqlSession.java */ public T selectOne(String
Mybatis工作机制源码分析—缓存机制及事务机制
探索java技术、web技术
01-15 985
本文主要以源码分析的角度分析Mybatis的缓存工作机制及事务机制。 缓存工作机制 整体设计图          网上一张关于Mybatis的缓存工作机制示意图： Cache类结构图 相关源码          二级缓存处理主要体现在CachingExecutor；一级缓存处理主要体现在BaseExecutor，其带localCache、localOutputParam
深入解析Mybatis源码：设计模式与工作流程
"Mybatis源码分析主要涵盖了Mybatis的工作流程、设计模式应用以及源码解析，旨在深入理解Mybatis的内部机制。" 在Mybatis的源码分析中，我们可以看到以下几个关键知识点： 1. **Mybatis工作流程**： Mybatis的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值