需求： 开发 生成 数据库 同步基础数据 但是又不能直接覆盖表 这时候同步起来 很麻烦

解决方案：在开发中 添加 更新 删除的 基础数据 执行的 sql 语句 存到开发数据库 需要同步 到线上时直接执行 存在 开发数据的 sql 语句 即可

需求： 有的时候 需要动态 拼接 sql 比如 数据权限 根据权限不同 拼接不同的 where 条件

也可以在 Mybatis 拦截器 中实现

下面的代码 主要是 拦截 执行的 sql 语句 存储到 数据库

第一步： 定义 Mybatis 拦截器

ini
 代码解读
复制代码
package com.erp.init.mybatisplus;


import com.erp.init.sqlLog.SqLogUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
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.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.stereotype.Component;

import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.Statement;
import java.util.Map;
import java.util.Properties;
//在mybatis中可被拦截的类型有四种(按照拦截顺序)：
//
//        Executor: 拦截执行器的方法。
//        ParameterHandler: 拦截参数的处理。
//        ResultHandler：拦截结果集的处理。
//        StatementHandler: 拦截Sql语法构建的处理。
//@Intercepts({
//    @Signature(type = StatementHandler.class, method = "query", args = {Statement.class, ResultHandler.class}),
//    @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}),
//    @Signature(type = StatementHandler.class, method = "batch", args = {Statement.class})
//})
//	1. @Intercepts：标识该类是一个拦截器；
//      @Signature：指明自定义拦截器需要拦截哪一个类型，哪一个方法；
//    2.1 type：对应四种类型中的一种；
//    2.2 method：对应接口中的哪类方法（因为可能存在重载方法）；
//    2.3 args：对应哪一个方法；
@Intercepts({
        @Signature(type = StatementHandler.class, method = "update", args = {Statement.class}),
        @Signature(type = StatementHandler.class, method = "batch", args = {Statement.class})
})
@Slf4j
@Component  // 必须要交给 spring boot 管理
public class MybatisLogInterceptor implements Interceptor {

     //这个方法里 是重点  主要是拦截 需要执行的sql  
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 执行方法
        Object result = invocation.proceed();

        // 获取MapperStatement对象，获取到sql的详细信息
        Object realTarget = realTarget(invocation.getTarget());
        // 获取metaObject对象
        MetaObject metaObject = SystemMetaObject.forObject(realTarget);
        // 获取MappedStatement对象
        MappedStatement ms = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        // 获取方法的全类名称
        String methodFullName = ms.getId();

        // 判断是否是需要日志记录的方法
        //   我用的是 Mybatis 提供的方法  methodFullName  这个可以获取到 方法 全类名 
        //  如果是 写的 原生 sql 执行的 没测试过  需要 测试一下使用
        Map map = SqLogUtil.verifyRecordLog(methodFullName);
        if (!map.isEmpty() && (boolean) map.get("isRecord")) {

            Statement statement;
            // 获取方法参数
            Object[] args = invocation.getArgs();
            Object firstArg = args[0];
            if (Proxy.isProxyClass(firstArg.getClass())) {
                statement = (Statement) SystemMetaObject.forObject(firstArg).getValue("h.statement");
            } else {
                statement = (Statement) firstArg;
            }
             // 这个对象里 有好几个 statement 和 stmt
            // 可以打打断点 看啊看 statement 这个对象里的数据结构
            MetaObject stmtMetaObj = SystemMetaObject.forObject(statement);
            Object stmt = stmtMetaObj.getValue("stmt");
            MetaObject metaObject1 = SystemMetaObject.forObject(stmt);
            Object statement1 = metaObject1.getValue("statement");
            MetaObject metaObject2 = SystemMetaObject.forObject(statement1);
            // mybatis 最后执行的sql 就在 这个对象里
            Object stmt1 = metaObject2.getOriginalObject();
            String finalSql=stmt1.toString();
            //去掉不要的字符串
            finalSql = finalSql.substring(finalSql.indexOf(":") + 1, finalSql.length());

            log.info("最终sql： \n " + finalSql);
              
            String saveLogSql = SqLogUtil.getSaveLogSql(methodFullName, (String) map.get("desc"), finalSql);

            if (StringUtils.isNotBlank(saveLogSql)) {
                Connection connection = statement.getConnection();

                if (connection.isReadOnly()) { // 当前事务是只读事务,则重新用不同的Connection对象
                    Connection mysqlConnection = SqLogUtil.getMysqlConnection();
                    if (mysqlConnection != null) {
                        try {
                            mysqlConnection.createStatement().execute(saveLogSql);
                        } catch (Exception e) {
                            e.printStackTrace();
                            log.error("拦截器记录日志出错!", e);
                        } finally {
                            mysqlConnection.close();//关闭连接
                        }
                    }
                } else {
                    connection.createStatement().execute(saveLogSql);
                }
            }
        }
        return result;
    }

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

    @Override
    public void setProperties(Properties prop) {

    }

    /**
     * 

     * 获得真正的处理对象,可能多层代理.
     * 

     */
    @SuppressWarnings("unchecked")
    public static  T realTarget(Object target) {
        if (Proxy.isProxyClass(target.getClass())) {
            MetaObject metaObject = SystemMetaObject.forObject(target);
            return realTarget(metaObject.getValue("h.target"));
        }
        return (T) target;
    }
}

第二步： 创建一个 sql 存储 工具类

java
 代码解读
复制代码
package com.erp.init.sqlLog;

import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.util.JdbcConstants;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * User: Json
 * 

 * Date: 2022/11/22
 **/
@Component  // 必须要交给 spring boot 管理
@Slf4j
public class SqLogUtil {
    /**
     * 判断哪个方法 需要被记录  
     * 这是一种方法 也可以设计成注解的形式 判断注解
     *  我用的是 Mybatis 提供的方法 
     *  如果是 写的 原生 sql 执行的 没测试过  需要 测试一下使用
     */
    public static final String[] DEFAULT_RECORD_METHOD_START = {
            "com.erp.base.mapper.YsDictMapper.updateById",
            "com.erp.base.mapper.YsDictMapper.insert",
            "com.erp.base.mapper.YsDictMapper.deleteById",
            "com.erp.base.mapper.YsDictSubMapper.insert",
            "com.erp.base.mapper.YsDictSubMapper.updateById",
            "com.erp.base.mapper.YsDictSubMapper.deleteById",
            "com.erp.base.mapper.YsFormMapper.insert",
            "com.erp.base.mapper.YsFormMapper.updateById",
            "com.erp.base.mapper.YsFormMapper.delete"
    };

    /**
     * 默认不记录的操作方法（记录日志的方法）
     * 这个是 执行 Mapper 里的方法
     * YsSqlLogMapper  类里的 方法
     */
    public static final String[] DEFAULT_NOT_RECORED_METHOD = new String[]{"com.erp.base.mapper.YsSqlLogMapper.saveSqlLog"};

    private static SqLogUtil logUtils;

    /**
     * 注入SqlSessionFactory对象
     */
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    /**
     * 注入DataSource对象
     */
    @Autowired
    private DataSource mysqlDataSource;

    public SqLogUtil() {
    }

    /**
     * 给logUtils对象赋值
     */
    @PostConstruct
    public void init() {
        logUtils = this;
        logUtils.sqlSessionFactory = this.sqlSessionFactory;
        logUtils.mysqlDataSource = this.mysqlDataSource;
    }

    /**
     * 验证方法是否需要日志记录
     *
     * @param methodFullName
     * @return
     */
    public static Map verifyRecordLog(String methodFullName) {
        Map resultMap = new HashMap<>();

        for (int i = 0; i < DEFAULT_NOT_RECORED_METHOD.length; i++) {
            if (methodFullName.equals(DEFAULT_NOT_RECORED_METHOD[i])) {
                return resultMap;
            }
        }

        boolean isRecord = false;

        String desc = "";
        int flag = methodFullName.lastIndexOf(".");
        String classPath = methodFullName.substring(0, flag);
        String methodName = methodFullName.substring(flag + 1);
        Class clazz = null;
        try {
            clazz = Class.forName(classPath);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            log.error("判断是否需要记录日志异常!", e);
        }
        if (clazz != null) {
            if (verifyMethodName(methodFullName)) {
                isRecord = true;
            }
        }
        resultMap.put("isRecord", isRecord); // 是否记录
        resultMap.put("desc", desc); // 方法描述
        return resultMap;
    }


    /**
     * 判断方法名是否满足日志记录格式
     *
     * @param methodName
     * @return
     */
    public static boolean verifyMethodName(String methodName) {
        boolean methodNameFlag = false;
        for (int i = 0; i < DEFAULT_RECORD_METHOD_START.length; i++) {
            if (methodName.startsWith(DEFAULT_RECORD_METHOD_START[i])) {
                methodNameFlag = true;
                break;
            }
        }
        return methodNameFlag;
    }


    /**
     * 填充日记记录SQL参数
     *
     * @param methodFullName
     * @param desc
     * @param originalSql
     * @return
     */
    private static List getParamList(String methodFullName, String desc, String originalSql) {
        List paramList = new ArrayList<>();
        // 完整SQL语句
        paramList.add(handlerSql(originalSql));
        //时间
        paramList.add(LocalDateTime.now().toString());
        return paramList;
    }

    /**
     * 处理SQL语句
     *
     * @param originalSql
     * @return
     */
    private static String handlerSql(String originalSql) {
      //  String sql = originalSql.substring(originalSql.indexOf(":") + 1);
        // 将原始sql中的空白字符（\s包括换行符，制表符，空格符）替换为" "
        return originalSql.replaceAll("[\\s]+", " ");
    }

    /**
     * 获取日志保存SQL
     *
     * @param methodFullName
     * @param desc
     * @param originalSql
     * @return
     */
    public static String getSaveLogSql(String methodFullName, String desc, String originalSql) {
        String sql = logUtils.sqlSessionFactory.getConfiguration()
                .getMappedStatement(DEFAULT_NOT_RECORED_METHOD[0]).getBoundSql(null).getSql();
        List paramList = getParamList(methodFullName, desc, originalSql);
        // paramList  是你需要存到数据库的 数据  
        sql = paramList != null && !paramList.isEmpty() ? SQLUtils.format(sql, JdbcConstants.MYSQL, paramList) : null;
        return sql;
    }

    /**
     * 获取mysql Connection对象
     *
     * @return
     */
    public static Connection getMysqlConnection() {
        Connection conn = null;
        try {
            conn = logUtils.mysqlDataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("保存日志时获取Connection对象异常!", e);
        }

        return conn;
    }


}



第三步：
创建一个 存储sql 语句的 Mapper 方法


java
 代码解读
复制代码
package com.erp.base.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.erp.api.entities.base.base.YsSqlLog;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

/**
 * 

 * sql日志表 Mapper 接口
 * 

 *
 * @author Json
 * @since 2022-11-22
 */
@Mapper
public interface YsSqlLogMapper extends BaseMapper {


    @Insert({"insert into ys_sql_log(sql_info,date) values(#{ysSqlLog.sqlInfo},#{ysSqlLog.createTime})"})
    int saveSqlLog(YsSqlLog ysSqlLog);

}




最后再执行 sql 的时候 数据库表里 就会记录 执行的 sql 语句


1.png

                
                

                    注：本文转载自juejin.cn的Json_的文章"https://juejin.cn/post/7444766313262530569"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
                

                

                    

                        

                            

                                
                                
                                
                                
                                    
                                
                                
                                
                                
                                
                                
                                
                                
                                
                                
                                

                                    复制链接
                                    
                                

                                

                                    
                                    

                                        

                                            

                                        

                                    

                                

                            

                        

                    

                


                

                    





                        
                    

                

                

                
            



            
            

                
相关推荐

                

                    

                    

                

            

            

                

                    

                        

							
								发表评论
                        

                        
                    

                    

                        

                            

								
                            

                            

                                

                                    

                                        
                                    

                                    

                                        
                                    

                                

                            

                            

                                
                            

                        

                        
评论记录：

                        
                        
                        
                        
                        
                        
未查询到任何数据！