DefaultSqlSession第一讲query解析

企业开发 2018-05-11 23:00:00 阅读次数: 1
上一篇文章：我们说过DefaultSqlSession，DefaultSqlSessionFactory根据执行器类型，事务级别，是否提交等信息，来构建执行器Executor，然后根据执行器和configuration构建SqlSession，默认为DefaultSqlSession，从DefaultSqlSession的类信息方法来看，DefaultSqlSession的查询则委托给executor的query，插入，更新，删除，则委托给executor的update，提交，回滚，清除缓存，刷新Statement，关闭SqlSession，都是委托给Executor的相应方法。这一节节我们来Executor
//执行器的构建
//根据数据源，事务级别，是否自动提交,创建执行器 
org.apache.ibatis.executor.Executor executor = configuration.newExecutor(tx, execType, autoCommit);

//Configuration 
public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit)
    {
        executorType = executorType != null ? executorType : defaultExecutorType;
        executorType = executorType != null ? executorType : ExecutorType.SIMPLE;
        Executor executor;
        if(ExecutorType.BATCH == executorType)
            executor = new BatchExecutor(this, transaction);
        else
        if(ExecutorType.REUSE == executorType)
            executor = new ReuseExecutor(this, transaction);
        else
            executor = new SimpleExecutor(this, transaction);
        if(cacheEnabled)
            executor = new CachingExecutor(executor, autoCommit);
	//将执行器插入到拦截器链中
        executor = (Executor)interceptorChain.pluginAll(executor);
        return executor;
}

从上面configuration的创建执行器方法，可以看出执行器有BatchExecutor，ReuseExecutor，SimpleExecutor
根据执行器类型，创建执行器，如果缓存启用，则包装executor为CachingExecutor；
//BatchExecutor 
public class BatchExecutor extends BaseExecutor
{
    public static final int BATCH_UPDATE_RETURN_VALUE = -2147482646;
    private final List statementList = new ArrayList();
    private final List batchResultList = new ArrayList();
    private String currentSql;
    private MappedStatement currentStatement;
    public BatchExecutor(Configuration configuration, Transaction transaction)
    {
        super(configuration, transaction);
    }
}

//SimpleExecutor 
public class SimpleExecutor extends BaseExecutor
{
    public SimpleExecutor(Configuration configuration, Transaction transaction)
    {
        super(configuration, transaction);
    }
}


//CachingExecutor 
public class CachingExecutor
    implements Executor
{
    private Executor _flddelegate;
    private boolean autoCommit;
    private TransactionalCacheManager tcm;
    private boolean dirty;
    public CachingExecutor(Executor delegate)
    {
        this(delegate, false);
    }
    public CachingExecutor(Executor delegate, boolean autoCommit)
    {
        tcm = new TransactionalCacheManager();
        _flddelegate = delegate;
        this.autoCommit = autoCommit;
    }
    public Transaction getTransaction()
    {
        return _flddelegate.getTransaction();
    }
    //更新
    public int update(MappedStatement ms, Object parameterObject)
        throws SQLException
    {
        //刷新刷新
        flushCacheIfRequired(ms);
	//调用代理更新
        return _flddelegate.update(ms, parameterObject);
    }
    //查询
    public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)
        throws SQLException
    {
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
    //查询
    public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
        throws SQLException
    {
        Cache cache;
        cache = ms.getCache();
        if(cache == null)
            break MISSING_BLOCK_LABEL_183;
        flushCacheIfRequired(ms);
        if(!ms.isUseCache() || resultHandler != null)
            break MISSING_BLOCK_LABEL_183;
        ensureNoOutParams(ms, key, parameterObject, boundSql);
        if(dirty)
            break MISSING_BLOCK_LABEL_147;
        cache.getReadWriteLock().readLock().lock();
        List list1;
        List cachedList = (List)cache.getObject(key);
        if(cachedList == null)
            break MISSING_BLOCK_LABEL_105;
        list1 = cachedList;
        cache.getReadWriteLock().readLock().unlock();
        cache.getReadWriteLock().readLock().unlock();
        cache.getReadWriteLock().readLock().unlock();
        //调用代理查询
        List list = _flddelegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list);
        return list;
        return _flddelegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

    public List flushStatements()
        throws SQLException
    {
        return _flddelegate.flushStatements();
    }

    public void commit(boolean required)
        throws SQLException
    {
        _flddelegate.commit(required);
        tcm.commit();
        dirty = false;
    }
   
    public void rollback(boolean required)
        throws SQLException
    {
        _flddelegate.rollback(required);
        dirty = false;
        if(required)
            tcm.rollback();
        break MISSING_BLOCK_LABEL_43;
        if(required)
            tcm.rollback();
        throw exception;
    }
       public void clearLocalCache()
    {
        _flddelegate.clearLocalCache();
    }
}

从上可以看出CachingExecutor是SimpleExecutor，BatchExecutor等执行器代理执行器；
事务的获取，清除缓存，更新，查询操作实际上，是调用Executor的相应方法。SimpleExecutor，
BatchExecutor为实际执行器，继承BatchExecutor；
下面根据DefaultSqlSession，来看执行器的query，update，提交，回滚，清除缓存，刷新Statement，
关闭SqlSession 
public class DefaultSqlSession
    implements SqlSession
{
    private Configuration configuration;
    private Executor executor;
    private boolean dirty;
    public DefaultSqlSession(Configuration configuration, Executor executor)
    {
        this.configuration = configuration;
        this.executor = executor;
        dirty = false;
    }
    //查询
    public Object selectOne(String statement)
    {
        return selectOne(statement, null);
    }
    public Object selectOne(String statement, Object parameter)
    {
        List list = selectList(statement, parameter);
        if(list.size() == 1)
            return list.get(0);
        if(list.size() > 1)
            throw new TooManyResultsException((new StringBuilder()).append("Expected one result (or null) to be returned by selectOne(), but found: ").append(list.size()).toString());
        else
            return null;
    }
    public List selectList(String statement)
    {
        return selectList(statement, null);
    }

    public List selectList(String statement, Object parameter)
    {
        return selectList(statement, parameter, RowBounds.DEFAULT);
    }
    public List selectList(String statement, Object parameter, RowBounds rowBounds)
    {
        List list;
        try
        {
            org.apache.ibatis.mapping.MappedStatement ms = configuration.getMappedStatement(statement);
	    //调用executor的查询方法
            List result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
            list = result;
        }
    }
    //插入
     public int insert(String statement)
    {
        return insert(statement, null);
    }

    public int insert(String statement, Object parameter)
    {
       //委托给update方法
        return update(statement, parameter);
    }

    public int update(String statement)
    {
        return update(statement, null);
    }

    public int update(String statement, Object parameter)
    {
        int i;
        try
        {
            dirty = true;
            org.apache.ibatis.mapping.MappedStatement ms = configuration.getMappedStatement(statement);
            //委托给executor的update
	    i = executor.update(ms, wrapCollection(parameter));
        }
    }
    //删除
     public int delete(String statement)
    { 
        //委托给update
        return update(statement, null);
    }

    public int delete(String statement, Object parameter)
    {
        return update(statement, parameter);
    }
    //提交
     public void commit()
    {
        commit(false);
    }

    public void commit(boolean force)
    {
        try
        {
	    //委托executor的commit
            executor.commit(isCommitOrRollbackRequired(force));
            dirty = false;
        }
    }
    //回滚
     public void rollback()
    {
        rollback(false);
    }

    public void rollback(boolean force)
    {
        try
        {
	    //委托executor的rollback
            executor.rollback(isCommitOrRollbackRequired(force));
            dirty = false;
        }
    }
    //清除缓存
    public void clearCache()
    {
	////委托executor的clearLocalCache
        executor.clearLocalCache();
    }
    //刷新Statements
    public List flushStatements()
    {
        List list;
        try
        {
	    //委托executor的flushStatements
            list = executor.flushStatements();
        }
    }
    //关闭SqlSession
    public void close()
    {
        //委托executor的close
        executor.close(isCommitOrRollbackRequired(false));
        dirty = false;
    }
}

先来看SqlSession 
public List selectList(String statement, Object parameter, RowBounds rowBounds)
    {
        List list;
        try
        {
            org.apache.ibatis.mapping.MappedStatement ms = configuration.getMappedStatement(statement);
	    //调用executor的查询方法
            List result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
            list = result;
        }
    }

代理执行器调用实际执行器BatchExecutor，ReuseExecutor，SimpleExecutor的query的方法
//CachingExecutor
//查询
    
public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler)
        throws SQLException
    {
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
    //查询
    public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
        throws SQLException
    {
        List list = _flddelegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list);
        return list;
        return _flddelegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

查看BatchExecutor，ReuseExecutor，SimpleExecutor的query的方法，实际上是在BaseExecutor
//BaseExecutor 
public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)
        throws SQLException
    {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
	//委托给query(ms, parameter, rowBounds, resultHandler, key, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

    public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
        throws SQLException
    {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if(closed)
            throw new ExecutorException("Executor was closed.");
        if(queryStack == 0 && ms.isFlushCacheRequired())
            clearLocalCache();
        List list;
        queryStack++;
        list = resultHandler != null ? null : (List)localCache.getObject(key);
        if(list != null)
	    //从本地获取查询结果
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        else
	    //从数据库查询结果
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        return list;
    }
    //从数据库查询结果
     private List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
        throws SQLException
    {
        localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
	//委托给doQuery
        List list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        localCache.removeObject(key);
        break MISSING_BLOCK_LABEL_53;
        Exception exception;
        exception;
        localCache.removeObject(key);
        throw exception;
        localCache.putObject(key, list);
        if(ms.getStatementType() == StatementType.CALLABLE)
            localOutputParameterCache.putObject(key, parameter);
        return list;
    }
    //doQuery为抽象方法，待子类扩展
     protected abstract List doQuery(MappedStatement mappedstatement, Object obj, RowBounds rowbounds, ResultHandler resulthandler, BoundSql boundsql)
        throws SQLException;

这里我们来看一下SimpleExecutor
//SimpleExecutor 
public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
        throws SQLException
    {
        Statement stmt = null;
        List list;
        Configuration configuration = ms.getConfiguration();
	//构造StatementHandler
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);
        //获取Statement
	stmt = prepareStatement(handler, ms.getStatementLog());
	//执行查询
        list = handler.query(stmt, resultHandler);
	//关闭statement
        closeStatement(stmt);
        return list;
        Exception exception;
        exception;
        closeStatement(stmt);
        throw exception;
    }

//构造StatementHandler 
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);

//configuration 
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
    {
        //创建RoutingStatementHandler
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        //拦截器处理statementHandler，
	statementHandler = (StatementHandler)interceptorChain.pluginAll(statementHandler);
        return statementHandler;
    }

//RoutingStatementHandler 
public class RoutingStatementHandler
    implements StatementHandler
{
    private final StatementHandler _flddelegate;
    public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
    {
        static class _cls1
        {

            static final int $SwitchMap$org$apache$ibatis$mapping$StatementType[];

            static 
            {
                $SwitchMap$org$apache$ibatis$mapping$StatementType = new int[StatementType.values().length];
                try
                {
                    $SwitchMap$org$apache$ibatis$mapping$StatementType[StatementType.STATEMENT.ordinal()] = 1;
                }
                catch(NoSuchFieldError ex) { }
                try
                {
                    $SwitchMap$org$apache$ibatis$mapping$StatementType[StatementType.PREPARED.ordinal()] = 2;
                }
                catch(NoSuchFieldError ex) { }
                try
                {
                    $SwitchMap$org$apache$ibatis$mapping$StatementType[StatementType.CALLABLE.ordinal()] = 3;
                }
                catch(NoSuchFieldError ex) { }
            }
        }
       //根据StatementType，创建对应的StatementHandler
        switch(_cls1..SwitchMap.org.apache.ibatis.mapping.StatementType[ms.getStatementType().ordinal()])
        {
        case 1: // '\001'
            _flddelegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;

        case 2: // '\002'
            _flddelegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;

        case 3: // '\003'
            _flddelegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;

        default:
            throw new ExecutorException((new StringBuilder()).append("Unknown statement type: ").append(ms.getStatementType()).toString());
        }
    }

    public Statement prepare(Connection connection)
        throws SQLException
    {
        return _flddelegate.prepare(connection);
    }

    public void parameterize(Statement statement)
        throws SQLException
    {
        _flddelegate.parameterize(statement);
    }

    public void batch(Statement statement)
        throws SQLException
    {
        _flddelegate.batch(statement);
    }

    public int update(Statement statement)
        throws SQLException
    {
        return _flddelegate.update(statement);
    }

    public List query(Statement statement, ResultHandler resultHandler)
        throws SQLException
    {
        return _flddelegate.query(statement, resultHandler);
    }

    public BoundSql getBoundSql()
    {
        return _flddelegate.getBoundSql();
    }

    public ParameterHandler getParameterHandler()
    {
        return _flddelegate.getParameterHandler();
    }
}

从RoutingStatementHandler可以看出，更新，查询，预编译都是通过代理StatementHandler，具体根据StatementType创建对应的StatementHandler，SimpleStatementHandler，PreparedStatementHandler，CallableStatementHandler
//获取Statement 
stmt = prepareStatement(handler, ms.getStatementLog());
 private Statement prepareStatement(StatementHandler handler, Log statementLog)
        throws SQLException
    {
        //获取连接，这里实际上调用的为BaseExector的getConnection，从执行器的事务管理器获取连接
        java.sql.Connection connection = getConnection(statementLog);
	//预编译
        Statement stmt = handler.prepare(connection);
	//参数设置
        handler.parameterize(stmt);
        return stmt;
    }

//预编译 
Statement stmt = handler.prepare(connection);

实际为RoutingStatementHandler，通过本地代理，预编译Statement， 
public abstract class BaseStatementHandler
    implements StatementHandler
{
   //获取PrepareStatement
public Statement prepare(Connection connection)
        throws SQLException
    {
        protected final Configuration configuration;
        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;
        Statement statement;
        ErrorContext.instance().sql(boundSql.getSql());
        statement = null;
	//实例化Statement
        statement = instantiateStatement(connection);
        setStatementTimeout(statement);
        setFetchSize(statement);
        return statement;
    }
    //带子类扩展
     protected abstract Statement instantiateStatement(Connection connection)
        throws SQLException;
    
    //设置statement的超时时间
     protected void setStatementTimeout(Statement stmt)
        throws SQLException
    {
        Integer timeout = mappedStatement.getTimeout();
        Integer defaultTimeout = configuration.getDefaultStatementTimeout();
        if(timeout != null)
            stmt.setQueryTimeout(timeout.intValue());
        else
        if(defaultTimeout != null)
            stmt.setQueryTimeout(defaultTimeout.intValue());
    }
   //设置statement的FetchSize
    protected void setFetchSize(Statement stmt)
        throws SQLException
    {
        Integer fetchSize = mappedStatement.getFetchSize();
        if(fetchSize != null)
            stmt.setFetchSize(fetchSize.intValue());
    }
}

我们来看statement实例化：
//PreparedStatementHandler,这里我们来看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);
    }
    //实例化Statement
    protected Statement instantiateStatement(Connection connection)
        throws SQLException
    {
        //获取sql
        String sql = boundSql.getSql();
        if(mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator)
        {
            String keyColumnNames[] = mappedStatement.getKeyColumns();
            if(keyColumnNames == null)
                return connection.prepareStatement(sql, 1);
            else
	       //从connection返回PreparedStatement
                return connection.prepareStatement(sql, keyColumnNames);
        }
        if(mappedStatement.getResultSetType() != null)
            return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), 1007);
        else
            return connection.prepareStatement(sql);
    }
}

我们再看一下
//CallableStatementHandler 
public class CallableStatementHandler extends BaseStatementHandler
{
protected Statement instantiateStatement(Connection connection)
        throws SQLException
    {
        String sql = boundSql.getSql();
        if(mappedStatement.getResultSetType() != null)
            return connection.prepareCall(sql, mappedStatement.getResultSetType().getValue(), 1007);
        else
	   //从connection返回CallableStatement
            return connection.prepareCall(sql);
    }
}

从上面可以看出构造StatementHandler，实际上为RoutingStatementHandler，
RoutingStatementHandler更新，查询，预编译都是通过代理StatementHandler，具体根据StatementType创建对应的StatementHandler，SimpleStatementHandler，
PreparedStatementHandler，CallableStatementHandler，
由具体的StatementHandler,创建Statement
//参数设置 
handler.parameterize(stmt);

//PreparedStatementHandler 
public void parameterize(Statement statement)
        throws SQLException
    {
        parameterHandler.setParameters((PreparedStatement)statement);
    }

parameterHandler在BaseStatementHandler中 
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;
    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)
    {
        configuration = mappedStatement.getConfiguration();
        this.executor = executor;
        this.mappedStatement = mappedStatement;
        this.rowBounds = rowBounds;
        typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        objectFactory = configuration.getObjectFactory();
        if(boundSql == null)
        {
            generateKeys(parameterObject);
            boundSql = mappedStatement.getBoundSql(parameterObject);
        }
        this.boundSql = boundSql;
	//configuration创建ParameterHandler
        parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
        resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
    }
}

来看一下
//configuration创建ParameterHandler 
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql)
    {
        //从mappedStatement获取LanguageDriver，创建ParameterHandler
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        //拦截器链处理ParameterHandler
	parameterHandler = (ParameterHandler)interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
    }

//XMLLanguageDriver 
public class XMLLanguageDriver
    implements LanguageDriver
{
    public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql)
    {
        return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
    }

//DefaultParameterHandler 
public class DefaultParameterHandler
    implements ParameterHandler
{
    private final TypeHandlerRegistry typeHandlerRegistry;
    private final MappedStatement mappedStatement;
    private final Object parameterObject;
    private BoundSql boundSql;
    private Configuration configuration;
    public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql)
    {
        this.mappedStatement = mappedStatement;
        configuration = mappedStatement.getConfiguration();
        typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
        this.parameterObject = parameterObject;
        this.boundSql = boundSql;
    }
    //设置PreparedStatement的参数
    public void setParameters(PreparedStatement ps)
        throws SQLException
    {
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        //从boundSql获取参数映射
	List parameterMappings = boundSql.getParameterMappings();
        if(parameterMappings != null)
        {
            MetaObject metaObject = parameterObject != null ? configuration.newMetaObject(parameterObject) : null;
            for(int i = 0; i < parameterMappings.size(); i++)
            {
	        //获取parameterMapping
                ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);
                if(parameterMapping.getMode() == ParameterMode.OUT)
                    continue;
                String propertyName = parameterMapping.getProperty();
                Object value;
                if(boundSql.hasAdditionalParameter(propertyName))
                    value = boundSql.getAdditionalParameter(propertyName);
                else
                if(parameterObject == null)
                    value = null;
                else
                if(typeHandlerRegistry.hasTypeHandler(parameterObject.getClass()))
                    value = parameterObject;
                else
                    value = metaObject != null ? metaObject.getValue(propertyName) : null;
		//获取具体的TypeHandler
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                if(typeHandler == null)
                    throw new ExecutorException((new StringBuilder()).append("There was no TypeHandler found for parameter ").append(propertyName).append(" of statement ").append(mappedStatement.getId()).toString());
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if(value == null && jdbcType == null)
                    jdbcType = configuration.getJdbcTypeForNull();
		//typeHandler设置PreparedStatement参数
                typeHandler.setParameter(ps, i + 1, value, jdbcType);
            }

        }
    }
}

//BaseTypeHandler 
public abstract class BaseTypeHandler extends TypeReference
    implements TypeHandler
{
public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType)
        throws SQLException
    {
        if(parameter == null)
        {
            if(jdbcType == null)
                throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
            try
            {
                ps.setNull(i, jdbcType.TYPE_CODE);
            }
        } else
        {
	    //设置参数
            setNonNullParameter(ps, i, parameter, jdbcType);
        }
    }
    //待父类扩展
    public abstract void setNonNullParameter(PreparedStatement preparedstatement, int i, Object obj, JdbcType jdbctype)
        throws SQLException;
}

BaseTypeHandler的子类有Integer，Float，Double，Boolean，Day，TimeStamp，Clob，StringTypeHandler
这里我们来看StringTypeHandler 
public class StringTypeHandler extends BaseTypeHandler
{
public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
        throws SQLException
    {
        ps.setString(i, parameter);
    }
}

从上面可以看出，参数初始化实际上，是通过ParameterHandler来处理，ParameterHandler默认为DefaultParameterHandler，
DefaultParameterHandler初始化参数实际上，
是从boundSql获取statement参数映射parameterMappings，遍历parameterMappings
根据具体的parameterMapping，从parameterMapping获取TypeHandler
（Integer，Float，Double，Boolean，Day，TimeStamp，Clob，StringTypeHandler）
;最后由TypeHandler，去设置statement参数
//执行查询
l 
ist = handler.query(stmt, resultHandler);

//PreparedStatementHandler 
public List query(Statement statement, ResultHandler resultHandler)
        throws SQLException
    {
        PreparedStatement ps = (PreparedStatement)statement;
        ps.execute();
        return resultSetHandler.handleResultSets(ps);
    }

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

//关闭statement 
closeStatement(stmt);

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

总结：
Sqlsession查询，通过CachingExecutor代理，CachingExecutor是SimpleExecutor，BatchExecutor等执行器代理执行器；
事务的获取，清除缓存，更新，查询操作实际上，是调用Executor的相应方法。SimpleExecutor，BatchExecutor为实际执行器，继承BatchExecutor。SimpleExecutor查询，如果有缓存，则利用缓存，没有则用从数据库中查询，查询过程，构造StatementHandler，获取Statement，执行查询，关闭statement。

猜你喜欢

转载自donald-draper.iteye.com/blog/2339029
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022