Mybatis 注入全局参数

墨蓝 2022-08-09 15:48 149阅读 0赞

在项目中使用mybatis作为dao层，大部分时间都需要使用到mybatis提供的动态sql功能，一般情况下所有的表都是在同一个数据库下的，进行数据操作时都是使用jdbc中默认的schema。但是如果系统升级了，将一部分表抽到新的schema上，作为程序员可就苦逼了，在对应表的xml文件中都需要手动指定schema，如果schema再换呢？。。。。XXXXXXX

所以更好的办法就是全局配置，在官方文档[http://mybatis.github.io/mybatis-3/configuration.html\#plugins][http_mybatis.github.io_mybatis-3_configuration.html_plugins]中始终没找到如何配置全局的参数，倒是发现了plugins这个好东西。

简单来说就是拦截器，这就是一个重要的切入点。  
首先先根据文档配置好拦截器，因为我是同spring整合的，所以在spring的xml中配置：

这样拦截器就配置ok了，只需要实现方法：

public Object intercept(Invocation invocation)

和配置切入点，我们需要在做update和query的时候指定schema，在类上添加注解：

@Intercepts({ @Signature(method = "update", args = { MappedStatement.class, Object.class }, type = Executor.class),
            @Signature(method = "query", args = { MappedStatement.class, Object.class, RowBounds.class,
                    ResultHandler.class }, type = Executor.class) })

方法名称是固定的，具体可以看Executor这个借口定义。

既然找到了入口，就可以着手实现动态注入参数了。  
首先得找到切入点MappedStatement，主要的方法getBoundSql，在这个方法中的实现如下：

public BoundSql getBoundSql(Object parameterObject) {
        BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings == null || parameterMappings.size() <= 0) {
          boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
        }
    
        // check for nested result maps in parameter mappings (issue #30)
        for (ParameterMapping pm : boundSql.getParameterMappings()) {
          String rmId = pm.getResultMapId();
          if (rmId != null) {
            ResultMap rm = configuration.getResultMap(rmId);
            if (rm != null) {
              hasNestedResultMaps |= rm.hasNestedResultMaps();
            }
          }
        }
    
        return boundSql;
      }

boundSql其实是从sqlSource上获取的，继续跟进查看实现类：  
![这里写图片描述][20151030113014833]  
看到了吧DynamicSqlSource是不是感觉很亲切，看名字就知道是处理动态sql的。要证明很简单，只需要debug一下就知道了！

继续跟进发现它调用了SqlNode.apply()方法，该类也有很多实现。要找到具体是哪个类进行参数注入的，只需要在xml中随便加入动态参数，如：select \* from $\{db\}，运行后就可以看到各种错误了。这样就容易定位到了TextSqlNode这个类，具体实现可以自己去看看。

回过头来SqlNode.apply()这个方法有个参数DynamicContext，而在TextSqlNode的类中发现获取注入的参数对象其实是调用 context.getBindings().put(“value”, parameter); 哈哈 binggo， context.getBindings()是map对象，这就明了了，参数就是从map中获取的。那么需要注入全局参数，只需要在map中注入即可。

那么问题来了，该如何实现呢？主要还是使用反射和动态代理，仔细看看拦截器的实现

@Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }

Plugin.wrap也是使用动态代理的。

具体实现步骤：  
1、现根据MappedStatement获取到SqlSource对象  
2、如果是DynamicSqlSource则获取成员变量rootSqlNode就拿到了SqlNode对象  
3、使用动态代理，将SqlNode更换成我们代理类  
4、在代理类上调用apply方法时，动态注入全局参数

废话不多说，下面上源码：

import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    
    import org.apache.commons.lang3.StringUtils;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.ibatis.executor.Executor;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.SqlSource;
    import org.apache.ibatis.plugin.Interceptor;
    import org.apache.ibatis.plugin.Intercepts;
    import org.apache.ibatis.plugin.Invocation;
    import org.apache.ibatis.plugin.Plugin;
    import org.apache.ibatis.plugin.Signature;
    import org.apache.ibatis.scripting.xmltags.DynamicContext;
    import org.apache.ibatis.scripting.xmltags.DynamicSqlSource;
    import org.apache.ibatis.scripting.xmltags.SqlNode;
    import org.apache.ibatis.session.ResultHandler;
    import org.apache.ibatis.session.RowBounds;
    
    @Intercepts({ @Signature(method = "update", args = { MappedStatement.class, Object.class }, type = Executor.class),
            @Signature(method = "query", args = { MappedStatement.class, Object.class, RowBounds.class,
                    ResultHandler.class }, type = Executor.class) })
    public class SchemaInterceptor implements Interceptor {
    
        protected static Log LOG = LogFactory.getLog(SchemaInterceptor.class);
        private static final String SCHEMA = "schema";
    
        private String schema;
    
        private Set<Integer> sourceStorage = new HashSet<Integer>();
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
    
            Object[] args = invocation.getArgs();
    
            MappedStatement mappedStatement = (MappedStatement) args[0];
    
            SqlSource sqlSource = mappedStatement.getSqlSource();
    
            // 只拦截动态sql
            if (sqlSource instanceof DynamicSqlSource) {
    
                // 获取到sqlNode对象
                Field field = DynamicSqlSource.class.getDeclaredField("rootSqlNode");
                field.setAccessible(true);
                SqlNode sqlnode = (SqlNode) field.get(sqlSource);
    
                if (!sourceStorage.contains(sqlSource.hashCode())) {
    
                    // 获取动态代理对象
                    SqlNode proxyNode = proxyNode(sqlnode);
    
                    field.set(sqlSource, proxyNode);
    
                    sourceStorage.add(sqlSource.hashCode());
                }
    
            }
    
            int sqlSourceCount = sourceStorage.size();
    
            if (sqlSourceCount >= 1000) {
                LOG.error("========>sqlsource数量预警==================》");
            } else {
                LOG.info("=============>sqlSourceSize:" + sqlSourceCount);
            }
    
            return invocation.proceed();
    
        }
    
        private SqlNode proxyNode(SqlNode sqlnode) {
            SqlNode proxyNode = (SqlNode) Proxy.newProxyInstance(sqlnode.getClass().getClassLoader(),
                    new Class[] { SqlNode.class }, new SqlNodeInvocationHandler(sqlnode));
            return proxyNode;
        }
    
        @Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }
    
        @Override
        public void setProperties(Properties properties) {
            LOG.debug("setProperties====>" + properties);
        }
    
        private class SqlNodeInvocationHandler implements InvocationHandler {
    
            private SqlNode target;
    
            public SqlNodeInvocationHandler(SqlNode target) {
                super();
                this.target = target;
            }
    
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                DynamicContext context = (DynamicContext) args[0];
                context.getBindings().put(SCHEMA, schema);
                return method.invoke(target, args);
            }
    
        }
    
        public void setSchema(String schema) {
            if (StringUtils.isNotBlank(schema)) {
                if (!schema.endsWith(".")) {
                    schema += ".";
                }
            }
            this.schema = schema;
        }
    
    }

具体注入参数代码：

@Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { DynamicContext context = (DynamicContext) args[0]; context.getBindings().put("dbSchema", "myschema."); return method.invoke(target, args); }

还没有封装好，需要的自己再封装下就可以了！  
当然，功能是实现了，感觉还是不太优雅，有没有官方对外接口呢？

[http_mybatis.github.io_mybatis-3_configuration.html_plugins]: http://mybatis.github.io/mybatis-3/configuration.html#plugins
[20151030113014833]: /images/20220731/bf225d3907c5427b8fa332a984c7fc04.png