Mybais 源码分析四 StatementHandle

最新推荐文章于 2024-09-15 22:14:18 发布
最新推荐文章于 2024-09-15 22:14:18 发布
阅读量200 收藏
点赞数
分类专栏： Mybatis 文章标签： mybatis statementHandler satementhandler
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangbo14511/article/details/97514750
版权

StatementHandler负责处理Mybatis与JDBC之间Statement的交互，而JDBC中的Statement是负责与数据库进行交互的对象 。statementHandler有3种类型 SimpleStatementHandler,preparedStatementhandler，callableStatementHandler，我们可以在xml映射文件中配置

	<select id="mapkeyTest" resultType="map" parameterType="_int" statementType="STATEMENT">
		select * from user where id in (18,7)
	</select>

节点的属性statementType 有3个值 STATEMENT，PREPARED 或 CALLABLE 中的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。

1.StatementHandler接口

/**
 * 	StatementHandler接口，定义了一些基本功能
 * */
public interface StatementHandler {
	  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;

		  BoundSql getBoundSql();

		  ParameterHandler getParameterHandler();
}

2.mybatis取得statementhandler ： 在Executor中通过全局配置文件类Configuration.newStatementHandler取得statementHandler

  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

通过一个RoutingStatementHandler对象来取得StatementHandler

/**
 * 	路由StatementHandler，实现了StatementHandler，负责根据节点上配置的statementType类型来分发到不同的statementhandler实例上去
 * */
public class RoutingStatementHandler implements StatementHandler {
	
	//委托的目标实例
	private final StatementHandler delegate;

	//根据配置的statementType 来构建不同类型的StatementHandler
	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();
	}
}

RoutingStatementHandler 是一个处理分发的对象，根据statementType的不同，调用不同的StatementHandler。其本身不执行逻辑，都调用目标StatementHandler的对应方法

3.BaseStatementHandler

/**
 * 	实现了StatementHandler的基础抽象类，实现了一些基本的功能，但最终的执行sql的编译功能由其子类实现
 * */
public abstract class BaseStatementHandler implements StatementHandler {
	
	//核心的配置文件映射类
	protected final Configuration configuration;
	
	//用于构建结果集所映射的javabean
	protected final ObjectFactory objectFactory;
	//对参数类型，返回值类型做转换
	protected final TypeHandlerRegistry typeHandlerRegistry;
	//得到的结果集对象
	protected final ResultSetHandler resultSetHandler;
	//设置参数的对象
	protected final ParameterHandler parameterHandler;

	protected final Executor executor;
	protected final MappedStatement mappedStatement;
	protected final RowBounds rowBounds;

	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;
		
		//typeHandler，objectFactroy都是需要在全局配置文件中配置的，自然从configuration中取得
		this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
		this.objectFactory = configuration.getObjectFactory();

		if (boundSql == null) { // issue #435, get the key before calculating the statement
			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 BoundSql getBoundSql() {
		return boundSql;
	}

	public ParameterHandler getParameterHandler() {
		return parameterHandler;
	}
	
	//根据Connection取得Statement
	public Statement prepare(Connection connection) throws SQLException {
		ErrorContext.instance().sql(boundSql.getSql());
		Statement statement = null;
		try {
			//更具<select|update>等节点上配置的依赖驱动（ResultSetType属性）取得statement对象
			statement = instantiateStatement(connection);
			//设置查询，修改操作过期时间<select|update>等节点(timeout属性配置)，可以全局配置文件中配置defaultStatementTimeout	
			setStatementTimeout(statement);
			//这是一个给驱动的提示，尝试让驱动程序每次批量返回的结果行数和这个设置值相等<select|update>等节点(fetchSize属性配置)
			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);
		}
	}

	protected abstract Statement instantiateStatement(Connection c) 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);
		}
	}
}

BaseStatementHandler 其功能基本就是取得Statement对象，并且为statement的行为进行配置

simpleStatementHandler

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();
		//取得配置的主键，这个一般用于能支持自动生成主键的数据库，mysql，sqlServer,不能用于oracle
		KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
		//用于记录更新成功的条数
		int rows;
		//statement执行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;
	}
	
	//添加批量执行的sql
	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();
		statement.execute(sql);
		return resultSetHandler.<E>handleResultSets(statement);
	}

	/**
	 * 根据ResultSetType配置取得statement实例
	 * 
	 * ResultSet.TYPE_FORWORD_ONLY 结果集的游标只能向下滚动。
	 * ResultSet.TYPE_SCROLL_INSENSITIVE 结果集的游标可以上下移动，当数据库变化时，当前结果集不变。
	 * ResultSet.TYPE_SCROLL_SENSITIVE 返回可滚动的结果集，当数据库变化时，当前结果集同步改变
	 * */
	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 {
		// N/A
	}

}

PreparedStatementHandler



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;
    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;
    ps.execute();
    return resultSetHandler.<E> handleResultSets(ps);
  }

  //取得预编译对象，
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    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);
  }

}

CallableStatementHandler


public class CallableStatementHandler extends BaseStatementHandler {

  public CallableStatementHandler(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 {
    CallableStatement cs = (CallableStatement) statement;
    cs.execute();
    int rows = cs.getUpdateCount();
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    keyGenerator.processAfter(executor, mappedStatement, cs, parameterObject);
    resultSetHandler.handleOutputParameters(cs);
    return rows;
  }

  public void batch(Statement statement)
      throws SQLException {
    CallableStatement cs = (CallableStatement) statement;
    cs.addBatch();
  }

  public <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException {
    CallableStatement cs = (CallableStatement) statement;
    cs.execute();
    List<E> resultList = resultSetHandler.<E>handleResultSets(cs);
    resultSetHandler.handleOutputParameters(cs);
    return resultList;
  }

  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    if (mappedStatement.getResultSetType() != null) {
      return connection.prepareCall(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    } else {
      return connection.prepareCall(sql);
    }
  }

  public void parameterize(Statement statement) throws SQLException {
    registerOutputParameters((CallableStatement) statement);
    parameterHandler.setParameters((CallableStatement) statement);
  }
	//注册model = out的属性
  private void registerOutputParameters(CallableStatement cs) throws SQLException {
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    for (int i = 0, n = parameterMappings.size(); i < n; i++) {
      ParameterMapping parameterMapping = parameterMappings.get(i);
      if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
        if (null == parameterMapping.getJdbcType()) {
          throw new ExecutorException("The JDBC Type must be specified for output parameter.  Parameter: " + parameterMapping.getProperty());
        } else {
          if (parameterMapping.getNumericScale() != null && (parameterMapping.getJdbcType() == JdbcType.NUMERIC || parameterMapping.getJdbcType() == JdbcType.DECIMAL)) {
            cs.registerOutParameter(i + 1, parameterMapping.getJdbcType().TYPE_CODE, parameterMapping.getNumericScale());
          } else {
            if (parameterMapping.getJdbcTypeName() == null) {
              cs.registerOutParameter(i + 1, parameterMapping.getJdbcType().TYPE_CODE);
            } else {
              cs.registerOutParameter(i + 1, parameterMapping.getJdbcType().TYPE_CODE, parameterMapping.getJdbcTypeName());
            }
          }
        }
      }
    }
  }

}
w鸿叶
关注
专栏目录
MyBatis 核心配置综述之StatementHandler
Java极客技术
07-19 1万+
StatementHandler 是四大组件中最重要的一个对象，负责操作 Statement 对象与数据库进行交流，在工作时还会使用 ParameterHandler 和...
Java架构师之源码分析专题SpringBoot2.x、Spring5、SpringMVC、Mybatis源码分析
08-19
Java架构师之源码分析专题SpringBoot2.x、Spring5、SpringMVC、Mybatis源码分析，源码中我们可以学到很多东西，学习别人高效的代码书写、学习别人对设计模式的熟练使用、学习别人对整个架构的布局等等。目前...
MyBatis 源码分析——生成Statement接口实例
weixin_30457065的博客
02-20 117
JDBC的知识对于JAVA开发人员来讲在简单不过的知识了。PreparedStatement的作用更是胸有成竹。我们最常见用到有俩个方法：executeQuery方法和executeUpdate方法。这俩个方法之外还有一个execute方法。只是这个方法我们很少用。但是mybatis框架就是却用这个方法来实现的。不管mybatis用是哪一个方法来实现。有一点可以肯定——那就是必须得到Stateme...
Mybatis 之 StatementHandler
zsg88的专栏
09-11 660
0
mybatis源码阅读-执行器StatementHandle和ParameterHandler(五)
04-10 211
StatementHandle 类图 各个实现类的作用 SimpleStatementHandler 用于使用Statement操作数据库(不会使用参数化查询?) PreparedStatementHandler 用于使用PreparedStatement操作数据库(会使用参数化查询) CallableStatementHandler 用于使用CallableStat...
Mybatis源码之CallableStatementHandler
井底之蛙
01-07 1318
/** * @author Clinton Begin */ public class CallableStatementHandler extends BaseStatementHandler { public CallableStatementHandler(Executor executor, MappedStatement mappedStatement, Object para
MyBatis 中文注释源码
02-10
这个压缩包 "mybatis-3-master" 包含了 MyBatis 源码，带有中文注释，这对于学习和理解 MyBatis 的工作原理非常有帮助。以下是一些关键知识点： 1. **MyBatis 架构**： - MyBatis 主要由 SqlSessionFactory 和 ...
mybais-plugin 2.92破解
11-07
mybatis_plus 2.92，内含各版本破解补丁，目前最新版3.0不好破解，此版本适合开发使用
Springboot mybais配置多数据源过程解析
08-19
Springboot MyBatis 配置多数据源过程解析 在实际开发中，多数据源的配置是非常常见的，尤其是在分布式系统或微服务架构中。今天，我们将详细介绍如何在 Springboot 中使用 MyBatis 配置多数据源。...
SpringBoot集成Mybatis-Plus+代码生成工具_springbott_mybais_
10-04
在本文中，我们将深入探讨如何将SpringBoot与Mybatis-Plus结合，并利用代码生成工具提升开发效率。SpringBoot因其简洁的配置和快速的启动能力，已成为Java开发中的首选框架之一。Mybatis-Plus则是在Mybatis基础上...
17-Mybatis源码分析(StatementHandler数据库访问)
my_momo_csdn的博客
07-10 261
文章目录StatementHandler一、StatementHandler和Statement1.1 StatementHandler接口1.2 Statement接口二、StatementHandler2.1 接口2.2 实现类三、实现类分析3.1 BaseStatementHandler3.2 RoutingStatementHandler3.3 PreparedStatementHandl...
StatementHandler
weixin_33752045的博客
03-07 269
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis源码学习（五）——StatementHandler
最新发布
weixin_63445802的博客
09-15 1268
StatementHandler 类为 mybatis 执行 Statement 对象核心类，从之前的 Executor 的解析中可以看出所有与数据库交互的方法底层都是通过 StatementHandler 对象与其进行交互；因此为了继续探索 mybatis 与数据库的交互过程，本文将继续对 StatementHandler 进行分析。
Mybatis源码笔记之浅析StatementHandler
增量星球
06-01 4788
目录概述职责类图源码 概述 职责 首先了解一下statementHandler职责：主要负责处理MyBatis与JDBC之间Statement的交互，通俗而言就是负责操作Statement对象与数据库之间的交互。其执行过程中主要依赖ParameterHandler和ResultSetHandler进行参数绑定和结果实体类绑定。 类图 BaseStatementHandler：StatementHandler接口的抽象实现类，主要用于简化StatementHandler接口的实现难度，适配 器设计模式的体
【MyBatis】MyBatis 核心配置综述之StatementHandler
九师兄
05-14 1923
1.概述 转载：核心配置综述之StatementHandler 2.MyBatis 四大组件之StatementHandler StatementHandler 是四大组件中最重要的一个对象，负责操作 Statement 对象与数据库进行交流，在工作时还会使用 ParameterHandler 和 ResultSetHandler 对参数进行映射，对结果进行实体类的绑定 我们在搭建原生JDBC的时候，会有这样一行代码 Statement stmt = conn.createStatement(); //也可
mybatis中statementHandler的设计与实现
多看多听多总结
10-07 408
StatementHandler接口定义为 Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException; void parameterize(Statement statement) throws SQLException; void batch(Statement statement) throws SQLException; in
ExecutorMappedStatement、StatementHandler、ResultSetHandler源码分析
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
08-31 381
Configuration 、SqlSession、SqlSessionfactory源码分析目录概 述StatementHandler总结：ResultSetHandler分析：小结：参考资料和推荐阅读 LD is tigger forever，CG are not brothers forever， throw the pot and shine forever. Modesty is not false, solid is not naive, treacherous but not deceit
PreparedStatement的Batch功能
数据库技术
09-15 2261
即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.这样每执行一次都要对传入的语句编译一次.而如果你使用预编译语句.你传入的任何内容就不会和原来的语句发生任何匹配的关系.(前提是数据库本身支持预编译,但上前可能没有什么服务端数据库不支持编译了,只有少数的桌面数据库,就是直接文件访问的那些)只要全使用预编译语句,你就用不着对传入的数据做任何过虑.而如果使用普通的statement, 有可能要对drop,;
idea mybais插件
08-25
MyBatis是一个开源的持久化框架，用于将数据库操作和Java代码进行解耦。它提供了许多方便的功能和特性，而MyBatis插件则是用于扩展和定制MyBatis功能的组件。 MyBatis插件允许你在MyBatis的执行过程中拦截并修改SQL语句、参数和结果。你可以使用插件来实现一些自定义的逻辑，比如日志记录、性能监控、动态SQL增强等。 要创建一个MyBatis插件，你需要实现Intercepto接口，并覆盖其中的intercept方法。该方法会在MyBatis执行SQL语句前后被调用，你可以在其中编写自己的逻辑。同时，你还需要在插件类上添加@Intercepts注解，指定要拦截的目标方法。 以下是一个示例代码，展示了如何创建一个简单的MyBatis插件： ```java @Intercepts({ @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}), @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}) }) public class MyPlugin implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { // 在执行SQL前的逻辑 System.out.println("Before executing SQL"); // 执行原有的SQL语句 Object result = invocation.proceed(); // 在执行SQL后的逻辑 System.out.println("After executing SQL"); return result; } @Override public Object plugin(Object target) { // 将插件应用到目标对象上 return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { // 设置插件属性 } } ``` 在以上示例中，我们使用@Intercepts注解指定了要拦截的目标方法，这里选择了Executor类的query和update方法。然后在intercept方法中，我们添加了执行SQL前后的逻辑。最后，使用Plugin.wrap方法将插件应用到目标对象上。 当你完成了插件的开发后，需要在MyBatis配置文件中进行配置： ```xml <plugins> <plugin interceptor="com.example.MyPlugin"> <!-- 设置插件属性 --> <property name="key" value="value"/> </plugin> </plugins> ``` 以上是一个简单的MyBatis插件的实现示例，你可以根据自己的需求进行定制和扩展。希望对你有所帮助！如果你还有其他问题，可以继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值