Spring 事务 以及拦截器的前后关系实验 Mybatis 日志拦截

 

背景：当一个线程中，如果需要拦截所有当SQL日志，然后统一发送到一个同步器，就可以实现多个数据库实现同步主库，在进行红绿上线，或者灰度部署时候，可以实现生产库与测试库实时同步，从而达到实时可切换的效果

通过实验：

可知道拦截器中 按照以下顺序

1、before

2、after

3、AfterReturning  AfterThrowing

4、afterCommit

 

实验步骤：

有A() B()两个在serviceImpl下定义带方法，顺序是A中调用B

 

public void A()
{
B();


}

public void B()
{
 //Inser的操作
 throw new Exception("001");
}

实验结果

当B()声明了@Transactional,A() 没有声明的时候，那么B()之后，就算抛出异常，也会完美的插入执行成功。

当A()声明了@Transactional,就算B()没有声明的时候,B()只要抛出异常，数据也失败。

 

所以，只有Controller调用Service层那一个方法是否有事务，来决定之后是否有事务。

 

package com.chinamobile.scm.masterdata.interceptor;

import com.chinamobile.framework.common.context.InvokeTracer;
import com.chinamobile.framework.common.context.RequestContext;
import com.chinamobile.framework.utils.CollectionUtil;
import com.chinamobile.scm.masterdata.util.ThreadsMapUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ThreadUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.lang.reflect.Method;
import java.util.Deque;
import java.util.List;

/**
 * Intercept implementation for service component.<br>
 *
 * @author YangHang
 */
@Component
@Aspect
@Slf4j
public class MybatisServiceInterceptor {
    /**
     * Service切入点<br>
     */
    @Pointcut("execution(* com.chinamobile.scm.*.service.*.*(..)) || execution(* com.chinamobile.scm.service.*.*(..))")
    public void pointCut() {
    }

    /**
     * 后置异常通知
     */

    @AfterThrowing(pointcut = "pointCut()", throwing = "e")
    public void throwss(JoinPoint joinPoint, Throwable e) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        System.out.println("拦截方法异常时执行 本方法内不可事务 异常："+method.getName());
    }
    @AfterReturning("pointCut()")
    public void afterreturning(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        if(TransactionSynchronizationManager.isActualTransactionActive()) {
            String tid = String.valueOf(Thread.currentThread().getId());
          List<String> stringList= ThreadsMapUtil.getSqls(tid);
          if(CollectionUtils.isNotEmpty(stringList))
          {
             for(String item:stringList)
             {
                 log.info("SQL:"+item);
             }
          }
            ThreadsMapUtil.removeSQL(tid);
        }
        System.out.println("注解式拦截  本方法内可提交事务 返回"+method.getName());
    }
    @After("pointCut()")
    public void after(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
//
//            if(TransactionSynchronizationManager.isActualTransactionActive()) {
//                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
//                    @Override
//                    public void afterCommit() {
//                        System.out.println("send email after transaction commit...");
//                    }
//
//                });
//            }
        System.out.println("注解式拦截，结束"+method.getName());
    }
    @Before("pointCut()")
    public void before(JoinPoint joinPoint){
        Thread.currentThread().getId();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("方法规则式拦截,开始："+method.getName());

    }




}

package com.chinamobile.scm.masterdata.interceptor;


import com.alibaba.fastjson.JSON;
import com.chinamobile.scm.masterdata.util.ThreadsMapUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Field;
import java.sql.PreparedStatement;
import java.sql.Statement;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

/*
 *Mybatis 拦截器 允许使用的插件来拦截的方法包括 Executor (update, query, flushStatements, commit, rollback, getTransaction, close,
 * isClosed) ParameterHandler (getParameterObject, setParameters)
 */
@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 })})
@Slf4j
@Component
public class ExecutorInterceptor implements Interceptor {
    /**
     * 是否本地
     */
    public  boolean isSavedLocat=false;

    /**
     * 根目录
     */
    public  String sqllogpath="/Users/yh/sqllog";
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        log.debug("进入到开始整SQL到时候来:");

        Object target = invocation.getTarget();
        StatementHandler statementHandler = (StatementHandler)target;

        BoundSql boundSql = statementHandler.getBoundSql();

        String sql = showSql(boundSql);//boundSql.getSql();
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappings();
       // System.out.println(sql);

        String updatestr= JSON.toJSONString(boundSql);
        if(TransactionSynchronizationManager.isActualTransactionActive()) {
            String tid = String.valueOf(Thread.currentThread().getId());
            ThreadsMapUtil.setSQLs(tid, sql);
        }
        else
        {
            log.info("SQL:"+sql);
        }
        if(isSavedLocat) {
            writeFile(updatestr, sqllogpath);
        }
        return invocation.proceed();
    }

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

    @Override
    public void setProperties(Properties properties) {

    }


    private String getParameterValue(Object obj) {
        //to_timestamp(to_char(sysdate,'YYYY-MM-DD HH24:MI:SS'),'YYYY-MM-DD HH24:MI:SS')
        String value = null;
        if (obj instanceof String) {
            value = "'" + obj.toString() + "'";
        } else if (obj instanceof java.sql.Timestamp) {
            DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
            value = "to_timestamp(to_char(" + formatter.format(obj) + ",'YYYY-MM-DD HH24:MI:SS'),'YYYY-MM-DD HH24:MI:SS')";
        }
        else if (obj instanceof Date) {
            DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
            value = "'" + formatter.format(obj) + "'";
//	            System.out.println(value);
        } else {
            if (obj != null) {
                value = obj.toString();
            } else {
                value = "";
            }

        }
        return value;
    }

    public String showSql(BoundSql boundSql) {
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        if (parameterMappings.size() > 0 && parameterObject != null) {
            //TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
//            if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
//                sql = sql.replaceFirst("\\?", getParameterValue(parameterObject));
//
//            } else {
            Configuration configuration=new Configuration();
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    if (metaObject.hasGetter(propertyName)) {
                        Object obj = metaObject.getValue(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterValue(obj));
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        Object obj = boundSql.getAdditionalParameter(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterValue(obj));
                    }
                }
         //   }
        }
        return sql;
    }

    public  void writeFile(String data,String resultfilepath){
        try {

            Date date = new Date();
            String path=resultfilepath+"/"+new SimpleDateFormat("yyyy-MM-dd/").format(date);
            File f = new File(path);
            if(!f.exists()){
                f.mkdirs(); //创建目录
            }
            String filepath=path+ System.currentTimeMillis()+".json";

            File file = new File(filepath);
            if(!file.exists()){
                file.createNewFile();
            }
            FileWriter fw = null;
            //true:表示是追加的标志
            fw = new FileWriter(file, true);
            fw.write(data);
            fw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{

        }
    }
}

 

设置可以启动拦截SQL的部分

package com.chinamobile.scm.masterdata.interceptor;

import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Properties;

@Configuration
public class MybatisInterceptorConfig {
    @Bean
    public String myInterceptor(SqlSessionFactory sqlSessionFactory) {


        sqlSessionFactory.getConfiguration().addInterceptor(new ExecutorInterceptor());
//        sqlSessionFactory.getConfiguration().addInterceptor(executorInterceptor);
//        sqlSessionFactory.getConfiguration().addInterceptor(new ParamInterceptor());
//        sqlSessionFactory.getConfiguration().addInterceptor(new ResultInterceptor());
        return "interceptor";
    }
}