Mybatis源码分析(5) -- StatementHandler分析

最新推荐文章于 2024-06-25 09:30:00 发布
最新推荐文章于 2024-06-25 09:30:00 发布
阅读量148 收藏
点赞数
原文链接：https://my.oschina.net/xiaoqiyiye/blog/1625570
版权

Mybatis源码分析(5) -- StatementHandler分析

这一篇我们要分析一下StamentHandler的功能，在前面分析Executor的时候就提到过StatementHandler，Executor并没有真正的去执行数据库操作，而是交由StatementHanlder来处理的。

下面我们先看看StamentHandler接口提供的方法：

public interface StatementHandler {

	//从Connection中获取Stament对象
	Statement prepare(Connection connection) throws SQLException;
	
	//设置预处理参数
	void parameterize(Statement statement) throws SQLException;
	
	//调用批量操作
	void batch(Statement statement) throws SQLException;
	
	//更新操作
	int update(Statement statement) throws SQLException;
	
	//查询操作
	<E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException;
	
	//获取执行SQL语句的封装类BoundSql
	BoundSql getBoundSql();
	
	//参数处理器
	ParameterHandler getParameterHandler();

}

从StatementHandler接口功能来分析，StatementHandler主要提供了以下几个功能：

  1. 获取Statement实例，获取SQL封装
  2. 查询、修改数据库操作
  3. 处理预处理参数

StatementHandler接口的实现图是这样的：

StatementHandler
     |-------BaseStatementHandler（基础抽象语句处理器）
			   |-----------SimpleStatementHandler（简单SQL语句处理器）
			   |-----------PreparedStatementHandler(参数化SQL预定义处理器)
			   |-----------CallableStatementHandler（存储过程处理器）
     |-------RoutingStatementHandler（路由语句处理器）

下面我们分析一下各个实现类，对于CallableStatementHandler（存储过程处理器）这个就不分析了，平时用的也不多，大家可以自己看看。

BaseStatementHandler 基础抽象语句处理器

BaseStatementHandler是对StatementHandler最基础的实现，直接分析整个类。

public abstract class BaseStatementHandler implements StatementHandler {

	//配置对象，用于获取配置信息
	protected final Configuration configuration;
	
	//用于结果集对象的实例化创建
	protected final ObjectFactory objectFactory;
	
	//用于结果集字段类型转换
	protected final TypeHandlerRegistry typeHandlerRegistry;

	//结果集处理器，用于处理结果集
	protected final ResultSetHandler resultSetHandler;

	//参数处理器，用于处理预处理参数
	protected final ParameterHandler parameterHandler;
	
	//执行器
	protected final Executor executor;

	//SQL元数据的封装
	protected final MappedStatement mappedStatement;

	//用于处理结果集的行定位
	protected final RowBounds rowBounds;
	
	//封装了执行的SQL
	protected BoundSql boundSql;

	protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
		this.configuration = mappedStatement.getConfiguration();
		this.executor = executor;
		this.mappedStatement = mappedStatement;
		this.rowBounds = rowBounds;
		
		this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
		this.objectFactory = configuration.getObjectFactory();
		
		//如果没有传入boundSql，则内部生成
		if (boundSql == null) {
			generateKeys(parameterObject);
			boundSql = mappedStatement.getBoundSql(parameterObject);
		}

		this.boundSql = boundSql;

		this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
		this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
	}

	public Statement prepare(Connection connection) throws SQLException {
		ErrorContext.instance().sql(boundSql.getSql());
		Statement statement = null;
		try {
			//Statement的创建由抽象方法去实现
			statement = instantiateStatement(connection);
                        //设置语句查询超时
			setStatementTimeout(statement);
                        //设置获取值
			setFetchSize(statement);
			return statement;
		} catch (SQLException e) {
			closeStatement(statement);
			throw e;
		} catch (Exception e) {
			closeStatement(statement);
			throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
		}
	}

	//创建Statment，由子类去实现
	protected abstract Statement instantiateStatement(Connection connection) throws SQLException;

	protected void setStatementTimeout(Statement stmt) throws SQLException {
		Integer timeout = mappedStatement.getTimeout();
		Integer defaultTimeout = configuration.getDefaultStatementTimeout();
		if (timeout != null) {
			stmt.setQueryTimeout(timeout);
		} else if (defaultTimeout != null) {
			stmt.setQueryTimeout(defaultTimeout);
		}
	}

	protected void setFetchSize(Statement stmt) throws SQLException {
		Integer fetchSize = mappedStatement.getFetchSize();
		if (fetchSize != null) {
			stmt.setFetchSize(fetchSize);
		}
	}

        // 关闭Statement
	protected void closeStatement(Statement statement) {
		try {
			if (statement != null) {
				statement.close();
			}
		} catch (SQLException e) {
			//ignore
		}
	}

        // 使用键生成器生成key
	protected void generateKeys(Object parameter) {
		KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
		ErrorContext.instance().store();
		keyGenerator.processBefore(executor, mappedStatement, null, parameter);
		ErrorContext.instance().recall();
	}
}

BaseStatementHandler的实现很简单，为子类提供了共用的属性以及一个instantiateStatement(Connection connection)抽象方法，子类由这个抽象方法来创建具体的Statement实例，Statement、PreparedStatement、CallableStatement分别由子类提供。

SimpleStatementHandler 简单SQL语句处理器

public class SimpleStatementHandler extends BaseStatementHandler {

	public SimpleStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
		super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
	}

	public int update(Statement statement) throws SQLException {
                // 获取执行SQL
		String sql = boundSql.getSql();
                // 获取参数
		Object parameterObject = boundSql.getParameterObject();
                // 键生成器
		KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
		int rows;
		//执行SQL语句，并获取影响的行数
		if (keyGenerator instanceof Jdbc3KeyGenerator) {
			statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
			rows = statement.getUpdateCount();
			keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
		} else if (keyGenerator instanceof SelectKeyGenerator) {
			statement.execute(sql);
			rows = statement.getUpdateCount();
			keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
		} else {
			statement.execute(sql);
			rows = statement.getUpdateCount();
		}
		//返回语句执行影响的行数
		return rows;
	}

        // 批量操作
	public void batch(Statement statement) throws SQLException {
		String sql = boundSql.getSql();
		statement.addBatch(sql);
	}

        // 查询功能
	public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
		String sql = boundSql.getSql();
		//真实的调用JDBC操作数据库，将结果集交给ResultSetHandler去处理
		statement.execute(sql);
		return resultSetHandler.<E>handleResultSets(statement);
	}

	//创建Statment实例
	protected Statement instantiateStatement(Connection connection) throws SQLException {
		if (mappedStatement.getResultSetType() != null) {
			return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
		} else {
			return connection.createStatement();
		}
	}

	public void parameterize(Statement statement) throws SQLException {
		//Statement执行不需要设置预定义参数
	}

}

PreparedStatementHandler 参数化SQL预定义处理器

public class PreparedStatementHandler extends BaseStatementHandler {

	public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
		super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
	}

	public int update(Statement statement) throws SQLException {
		PreparedStatement ps = (PreparedStatement) statement;
		//执行SQL语句，获取影响的行数
		ps.execute();
		int rows = ps.getUpdateCount();
		Object parameterObject = boundSql.getParameterObject();
		KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
		keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
		//返回执行影响的行数
		return rows;
	}

        // 批量操作
	public void batch(Statement statement) throws SQLException {
		PreparedStatement ps = (PreparedStatement) statement;
		ps.addBatch();
	}

        // 查询操作
	public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
		PreparedStatement ps = (PreparedStatement) statement;
		//真实的调用JDBC操作数据库，将结果集交给ResultSetHandler去处理
		ps.execute();
		return resultSetHandler.<E> handleResultSets(ps);
	}

	protected Statement instantiateStatement(Connection connection) throws SQLException {
		String sql = boundSql.getSql();
		//创建PreparedStament实例
		if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
			String[] keyColumnNames = mappedStatement.getKeyColumns();
			if (keyColumnNames == null) {
				return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
			} else {
				return connection.prepareStatement(sql, keyColumnNames);
			}
		} else if (mappedStatement.getResultSetType() != null) {
			return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
		} else {
			return connection.prepareStatement(sql);
		}
	}

	public void parameterize(Statement statement) throws SQLException {
		//设置预定义参数，由参数处理器来设置
		parameterHandler.setParameters((PreparedStatement) statement);
	}
}

RoutingStatementHandler 路由语句处理器

RoutingStatementHandler是根据不同的statementType来选择创建不同的实例。这里就是用了简单工厂模式，根据不同的StatementType类型来创建相应的实例对象，然后具体的操作由这个delegate来处理。

public class RoutingStatementHandler implements StatementHandler {

	private final StatementHandler delegate;

	public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

		switch (ms.getStatementType()) {
			case STATEMENT:
				delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
				break;
			case PREPARED:
				delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
				break;
			case CALLABLE:
				delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
				break;
			default:
				throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
		}

	}

	public Statement prepare(Connection connection) throws SQLException {
		return delegate.prepare(connection);
	}
	
	public void parameterize(Statement statement) throws SQLException {
		delegate.parameterize(statement);
	}
	
	public void batch(Statement statement) throws SQLException {
		delegate.batch(statement);
	}
	
	public int update(Statement statement) throws SQLException {
		return delegate.update(statement);
	}
	
	public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
		return delegate.<E>query(statement, resultHandler);
	}
	
	public BoundSql getBoundSql() {
		return delegate.getBoundSql();
	}
	
	public ParameterHandler getParameterHandler() {
		return delegate.getParameterHandler();
	}
}

StatementHandler的源码我们都已经分析的差不多了，前面在分析Executor时就知道实际的数据库操作是委派给StatementHandler来处理的。那么，StatementHandler又是怎么创建的呢？StatementHandler是通过如下代码创建的：

StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);

StatementHandler的创建在Configuration中，下面我们看看这个方法：

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
	//创建RoutingStatementHandler，具体的子类需要根据StatementType去选择
	StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
	//如果设置了Interceptor，RoutingStatementHandler对象会被拦截器代理，关于拦截器是如何代理的，后面再说
	statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
	//返回被代理的StatementHandler对象
	return statementHandler;
}

StatementHandler很简单，就分析到这里了。StatementHandler执行SQL后结果集会交由ResultSetHandler去处理，下一篇中我们再看看结果集是怎么处理的。

转载于:https://my.oschina.net/xiaoqiyiye/blog/1625570

chenwei7858
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis 核心配置综述之StatementHandler
Java极客技术
07-19 1万+
StatementHandler 是四大组件中最重要的一个对象，负责操作 Statement 对象与数据库进行交流，在工作时还会使用 ParameterHandler 和...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
mybatis拦截器
sinat_41900642的博客
12-04 1175
mybatis拦截器 设置一个mybatis 拦截器 @Intercepts({@Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class})}) public class MYInsertPlugin implements Interceptor { @Override public Object intercept(Invocation i
教你手写Mybatis框架
weixin_34341229的博客
06-21 150
前言 (｡･∀･)ﾉﾞ嗨，小伙伴们，这篇博文将带大家手写mybatis，让大家对mybaits的核心原理以及工作流程有更加深刻的理解。在上篇Spring-Mybatis运行机制概括以及上上篇MyBatis原理概括发布后，由于本人事情较多导致这篇博文却迟迟没出来，这里需要跟大家深感抱歉。但是，这篇如果你看了，我想你应该会觉得这一切都是值得的...
Mybatis源码笔记之浅析StatementHandler
增量星球
06-01 4654
目录概述职责类图源码 概述 职责 首先了解一下statementHandler职责：主要负责处理MyBatis与JDBC之间Statement的交互，通俗而言就是负责操作Statement对象与数据库之间的交互。其执行过程中主要依赖ParameterHandler和ResultSetHandler进行参数绑定和结果实体类绑定。 类图 BaseStatementHandler：StatementHandler接口的抽象实现类，主要用于简化StatementHandler接口的实现难度，适配 器设计模式的体
MyBatis源码学习三——StatementHandler与拦截器原理
yx444535180的专栏
03-31 2874
文章目录一、StatementHandler1.1 RoutingStatementHandler1.2 PreparedStatementHandler二、拦截器2.1 InterceptorChain2.2 Intercepts注解三、PaginationInterceptor 一、StatementHandler 执行器Executer与缓存 上篇讲到一级缓存在BaseExecuter的queryFromDatabase()方法，当没有命中缓存时，从数据库中查询 doQuery(ms, parame
MyBatis 源码分析-- 插件（拦截器）原理
weixin_42118323的博客
06-25 872
Plugin#wrap 方法会获取目标对象的所有实现接口，通过 JDK 动态代理生成代理对象，对目标类进行代理，最终的执行器为 Plugin，通过JDK 动态代理创建了一个 Plugin 类，Plugin 实现了 InvocationHandler，熟悉动态代理的小伙伴应该都清楚，调用代理类的方法时，会调用invoke 方法，也就是说 Plugin 其实就是一个 InvocationHandler，最终会调用 Plugin#invoke 方法。同一个目标类的同一个方法是否可以被多个插件（拦截器）拦截？
持久层框架设计实现及MyBatis源码分析 ---- MyBatis基础回顾及高级应用
Amxrjgcs的博客
11-30 638
where + if 标签where标签mybatis会自动添加where语句，if标签根据if条件，如果成立，会为后面多个判断语句添加and(第一个除外)foreach 标签foreach标签的属性含义如下：• collection：代表要遍历的集合元素。作为入参,对象为list、array时，collection属性值分别默认用"list"、"array"代替，Map对象没有默认的属性值。
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
源码分析这部分，可以理解到 MyBatis 如何利用 Java 的反射和动态代理技术来实现这一特性。 4. **Executor**：执行器是 MyBatis 的心脏，它负责执行 SQL 语句。Executor 分为 SimpleExecutor、ReuseExecutor 和 ...
Mybatis源码分析.docx
05-23
Mybatis源码分析 Mybatis是一款流行的持久层框架，它提供了一个强大的机制来简化Java应用程序中的数据库交互。Mybatis的核心概念包括Configuration、SqlSessionFactory、Session、Executor、MappedStatement、...
mybatis-3-mybatis-3.5.7.zip源码
04-27
源码分析将帮助我们深入理解其工作原理和设计模式。 1. **配置文件解析**：MyBatis的核心配置文件`mybatis-config.xml`定义了数据源、事务管理器、Mappers等关键元素。通过`XMLConfigBuilder`解析这些配置，构建出`...
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
Matlab语言教程及案例
07-09
项目总结 本文详细介绍了Matlab的基础知识和一个完整的数据分析与可视化案例。内容包括： 1. **基本操作**：基本算术运算和矩阵操作。 2. **绘图**：二维和三维绘图。 3. **函数和脚本**：编写和运行Matlab函数和脚本。 4. **案例分析**：生成模拟数据，进行数据预处理、绘图和统计分析。 通过这个项目，读者可以掌握Matlab的基本使用方法，并了解如何在Matlab中进行数据分析和可视化。这对于初学者入门Matlab编程、提升数据处理和分析能力非常有帮助。希望本文能为读者提供有价值的参考，提升其Matlab编程和数据分析技能。
KB8825英文数据手册
07-09
三星KB8825英文数据手册
述职报告（08）PPT模板.pptx
07-09
述职报告（08）PPT模板.pptx
知识产权优势培育企业推荐表.docx
07-09
知识产权优势培育企业推荐表.docx
ssm将mybatis升级到mybatis-plus共存
01-05
将SSM框架中的MyBatis升级到MyBatis-Plus是可行的，可以实现共存。SSM框架由Spring、Spring MVC和MyBatis组成，而MyBatis-Plus是对MyBatis的增强扩展。下面将介绍如何将它们共存。 首先，需要将MyBatis升级到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值