Method loadDriver

executor/execenv.go:314–365

loadDriver 加载执行器 对单笔交易执行期间的执行器做了缓存，避免多次加载 只有参数的tx，index，和记录的当前交易，当前索引，均相等时，才返回缓存的当前交易执行器

(tx *types.Transaction, index int)

// 对单笔交易执行期间的执行器做了缓存，避免多次加载
// 只有参数的tx，index，和记录的当前交易，当前索引，均相等时，才返回缓存的当前交易执行器
func (e *executor) loadDriver(tx *types.Transaction, index int) (c drivers.Driver) {

	// 交易和index都相等时，返回已缓存的当前交易执行器
	if e.currExecTx == tx && e.currTxIdx == index {
		return e.currDriver
	}
	var err error
	name := types.Bytes2Str(tx.Execer)
	driver, ok := e.driverCache[name]
	isFork := e.cfg.IsFork(e.height, "ForkCacheDriver")

	if !ok {
		driver, err = drivers.LoadDriverWithClient(e.api, name, e.height)
		if err != nil {
			driver = e.loadNoneDriver()
		}
		e.driverCache[name] = driver
	}

	//fork之前，多笔相同执行器的交易只有第一笔会进行Allow判定，从缓存中获取的执行器不需要进行allow判定
	//fork之后，所有的交易均需要单独执行Allow判定
	//Allow判定主要目的是在主链中, 对平行链的交易只做存证, 而不进行实际的执行逻辑
	//Allow判定失败, 加载none执行器, 即平行链交易被认为是存证交易类型
	if !ok || isFork {
		driver.SetEnv(e.height, 0, 0)
		err = driver.Allow(tx, index)
	}

	// allow不通过时，统一加载none执行器
	if err != nil {
		driver = e.loadNoneDriver()
		//fork之前，cache中存放的是经过allow判定后，实际用于执行的执行器，比如主链执行平行链交易的执行器对应的是none对象
		//fork之后，cache中存放的是和Execer名称对应的driver对象, 如user.p.para.coins => coins
		//fork之前的问题在于cache缓存错乱，不应该缓存实际用于执行的，即缓存包含了allow的逻辑，导致错乱
		//正确逻辑是，cache中的执行器对象和名称是一一对应的，保证了driver对象复用，但同时不同交易的allow需要重新判定
		if !isFork {
			e.driverCache[name] = driver
		}
	} else {
		driver.SetName(types.Bytes2Str(types.GetRealExecName(tx.Execer)))
		driver.SetCurrentExecName(name)
	}
	e.setEnv(driver)

	//均不相等时，表明当前交易已更新，需要同步更新缓存，并记录当前交易及其index
	if e.currExecTx != tx && e.currTxIdx != index {
		e.currExecTx = tx
		e.currTxIdx = index
		e.currDriver = driver
	}
	return driver
}

func (e *executor) execTxGroup(txs []*types.Transaction, index int) ([]*types.Receipt, error) {
	txgroup := &types.Transactions{Txs: txs}