通过spring的AOP的切面，拦截到持久层执行的sql及参数

最新推荐文章于 2024-04-13 18:06:34 发布
最新推荐文章于 2024-04-13 18:06:34 发布
阅读量3.5k 收藏 15
点赞数 2
分类专栏： 一些问题 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingkongtianma01/article/details/120515844
版权

声明：文章内容是 自己使用后整理，大部分工具代码出自大牛，但因无法确认出处，故仅在此处由衷的对无私分享源代码的作者表示感谢与致敬！

使用该方式需要按规范书写所有的mapper方法，否则会报错！

方式一：形参为自定义实体类
void insert(User user);

方式二：形参为Map
void insert(Map<String,Object> map);

方式三：形参为list

void batchInsertUser(@Param(value = "list") List<UserDTO> list);

方式四：形参为单个或多个参数，需要使用@Param注解
void insert(@Param("userName") String userName, @Param("age")Integer age);

LogSqlAnnotation.java

package com.xxx.xxx.xxx.aspect;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
 
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface LogSqlAnnotation{
   
    String value() default "";
}

LogSqlAspect.java

package com.xxx.xxx.xxx.aspect;

import com.xxx.xxx.xxx.util.Func;
import com.xxx.xxx.xxx.util.SqlUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSessionFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Slf4j
//@Aspect
//@Component
public class LogSqlAspect {


    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    /**
     * 切点 扫描整个mapper
     *
     * @Pointcut("execution(* com.xxx.xxx.xxx.controller.*.*(..)) && @annotation(com.xxx.xxx.xxx.aspect.LogSqlAnnotation)")
     * @Pointcut("execution(* com.xxx.xxx.xxx.mappers.*.*(..))")
     */
    @Pointcut("execution(* com.xxx.xxx.xxx.mapper.*.*(..)) && !execution(* com.xxx.xxx.xxx.mapper.JobLogSqlMapper.*(..))")
    public void logRecord() {
        // 定义
    }

    /**
     * 前置通知
     *
     * @param jp
     */
    @Before(value = "logRecord()")
    public void before(JoinPoint jp) {
        String name = jp.getSignature().getName();
        log.info(name + "方法开始执行");
    }

    /**
     * 后置通知
     *
     * @param jp
     */
    @After(value = "logRecord()")
    public void after(JoinPoint jp) {
        String name = jp.getSignature().getName();
        log.info(name + "方法执行结束...");
    }

    /**
     * 返回通知
     *
     * @param jp
     * @param result
     */
    @AfterReturning(value = "logRecord()", returning = "result")
    public void afterReturning(JoinPoint jp, Object result) {
        String name = jp.getSignature().getName();
        log.info(name + "方法返回值为：" + result);
    }

    /**
     * 异常通知
     *
     * @param jp
     * @param e
     */
    @AfterThrowing(value = "logRecord()", throwing = "e")
    public void afterThrowing(JoinPoint jp, Exception e) {
        String name = jp.getSignature().getName();
        log.info(name + "方法异常：" + e.getMessage());
    }

    //    @Around(value = "logRecord()")
//    public Object around(ProceedingJoinPoint pjp) throws Throwable {
//        return pjp.proceed();
//    }


    @Around(value = "logRecord()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        String sql = SqlUtils.getMybatisSql(pjp, sqlSessionFactory);
        String dml= Func.getSqlDML(sql);
        String remark= Func.analyzeSqlWhere(sql);

        // 获取请求信息
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String requestUrl=null;
        if(requestAttributes!=null){
            HttpServletRequest request = requestAttributes.getRequest();
            requestUrl = request.getRequestURL().toString();
        }
        Signature signature = pjp.getSignature();
        String methodName = signature.getName();
        String methodUrl = signature.toShortString();

        log.info("记录执行sql--->dml:{}",dml);
        log.info("记录执行sql--->remark:{}",remark);
        if(remark!=null || (remark==null && dml != null && !"SELECT".equals(dml) )){
            log.info("记录执行sql--->sql:{}",sql);
            log.info("记录执行sql--->methodName:{}",methodName);
            log.info("记录执行sql--->methodUrl:{}",methodUrl);
            log.info("记录执行sql--->requestUrl:{}",requestUrl);
        }
        /*//<editor-fold desc="1、jdbc 保存日志">
        Connection connection = JdbcUtils.getConnection();
        Statement statement = connection.createStatement();
        String insertSql = "insert into logsql(log_id, sql_str, method_name, method_url, request_url, create_date) " +
                "values (" + "\'" + logId + "\'" + ","
                + "\"" + sql + "\"" + ","
                + "\"" + methodName + "\"" + ","
                + "\'" + methodUrl + "\'" + ","
                + "\'" + requestUrl + "\'" + ","
                + "NOW()" + ")";
        statement.executeUpdate(insertSql);
        //</editor-fold>*/

        /*//<editor-fold desc="2、mybatis 通过model方式保存">
        LogSql logSql = new LogSql();
        logSql.setLogId(logId);
        logSql.setMethodName(methodName);
        logSql.setMethodUrl(methodUrl);
        logSql.setSqlStr(sql);
        logSql.setRequestUrl(requestUrl);
        logSqlMapper.saveLogByModel(logSql);
        //</editor-fold>*/

        // 3、mybatis 通过 map方式保存"
//        Map<String, String> map = new HashMap<>(16);
//        map.put("sql_str", sql);
//        map.put("method_name", methodName);
//        map.put("method_url", methodUrl);
//        map.put("request_url", requestUrl);
//    logSqlMapper.saveLogByMap(map);

        return pjp.proceed();
    }

}

SqlUtils.java

package com.xxx.xxx.xxx.util;

import com.google.common.collect.Lists;
import com.xxx.xxx.xxx.model.log.LogSqlConstant;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.text.DateFormat;
import java.time.Instant;
import java.util.*;


/**
 * @date 2021/9/20 10:16
 * @description  获取aop中的SQL语句，借鉴来源https://blog.csdn.net/sdzhangshulong/article/details/104393244
 */
@Slf4j
public class SqlUtils {

    /**
     * 获取aop中的SQL语句
     *
     * @param pjp
     * @param sqlSessionFactory
     * @return
     * @throws IllegalAccessException
     */
    public static String getMybatisSql(ProceedingJoinPoint pjp, SqlSessionFactory sqlSessionFactory) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>(16);
        //1.获取namespace+methdoName
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        String namespace = method.getDeclaringClass().getName();
        String methodName = method.getName();
        //2.根据namespace+methdoName获取相对应的MappedStatement
        Configuration configuration = sqlSessionFactory.getConfiguration();
        MappedStatement mappedStatement = configuration.getMappedStatement(namespace + "." + methodName);
        //3.获取方法参数列表名
        Parameter[] parameters = method.getParameters();
        //4.形参和实参的映射,获取实参
        Object[] objects = pjp.getArgs();
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (int i = 0; i < parameterAnnotations.length; i++) {
            Object object = objects[i];
            //说明该参数没有注解，此时该参数可能是实体类，也可能是Map，也可能只是单参数
            if (parameterAnnotations[i].length == 0) {
                if (object.getClass().getClassLoader() == null && object instanceof Map) {
                    map.putAll((Map<? extends String, ?>) object);
                    log.info("该对象为Map");
                } else {//形参为自定义实体类
                    map.putAll(objectToMap(object));
                    log.info("该对象为用户自定义的对象");
                }
            } else {//说明该参数有注解，且必须为@Param
                for (Annotation annotation : parameterAnnotations[i]) {
                    if (annotation instanceof Param) {
                        map.put(((Param) annotation).value(), object);
                    }
                }
            }
        }
        //5.获取boundSql
        BoundSql boundSql = mappedStatement.getBoundSql(map);
//        BoundSql boundSql = mappedStatement.getBoundSql();
        return showSql(configuration, boundSql);
    }

    /**
     * 解析BoundSql，生成不含占位符的SQL语句
     *
     * @param configuration
     * @param boundSql
     * @return
     */
    private static String showSql(Configuration configuration, 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 {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    String[] s = metaObject.getObjectWrapper().getGetterNames();
                    s.toString();
                    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;
    }

    /**
     * 若为字符串或者日期类型，则在参数两边添加''
     *
     * @param obj
     * @return
     */
    private static String getParameterValue(Object obj) {
        String value = null;
        if (obj instanceof String) {
            value = "'" + obj.toString() + "'";
        } else if (obj instanceof Date) {
            DateFormat formatter = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
            value = "'" + formatter.format(new Date()) + "'";
        } else {
            if (obj != null) {
                value = obj.toString();
            } else {
                value = "";
            }
        }
        return value;
    }

    /**
     * 获取利用反射获取类里面的值和名称
     *
     * @param obj
     * @return
     * @throws IllegalAccessException
     */
    private static Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>(16);
        Class<?> clazz = obj.getClass();
        log.info("Class<?>={}",clazz);
        // 获取本类及其父类的属性，↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null) {
            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
            clazz = clazz.getSuperclass();
        }
        // 获取本类及其父类的属性，↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
        for (Field field : fieldList) {
            field.setAccessible(true);
            String fieldName = field.getName();
            Object value = field.get(obj);
            map.put(fieldName, value);
        }
        return map;
    }

    /**
     * 获取 DML 的 方式（insert、delete、update、select）
     * @param sql
     * @return
     */
    public static String getSqlDML(String sql) {

        if(Func.isEmpty(sql)){
            return null;
        }
        try {
            sql=sql.trim();
            int endIndex = sql.indexOf(" ")!=-1?sql.indexOf(" "):sql.length()>=6?6:sql.length();
            return sql.substring(0, endIndex).toUpperCase();
        } catch (Exception e) {
            log.error("SqlUtils- 获取sql的DML 异常",e);
            return null;
        }
    }

    /**
     * 获取表名
     * @param sql
     * @return
     */
    public static String getTableName(String sql) {

        String dml = getSqlDML(sql);

        if(Func.isEmpty(dml)){
            return null;
        }
        // LogSqlEnum.DmlEnum.UPDATE.equals(dml) || LogSqlEnum.DmlEnum.DELETE.equals(dml) || LogSqlEnum.DmlEnum.SELECT.equals(dml)
        try {
            sql = sql.substring(6).trim().toUpperCase();
            if((LogSqlConstant.DmlEnum.DELETE.equals(dml) || LogSqlConstant.DmlEnum.SELECT.equals(dml))
                    && sql.contains("FROM")){
                sql=sql.substring(sql.indexOf("FROM")+4).trim();
                String[] s = sql.split(" ");
                if(s.length>1){
                    return s[0].trim();
                }
            }
            if(LogSqlConstant.DmlEnum.UPDATE.equals(dml) && sql.contains("SET")){
                return sql.substring(6,sql.indexOf("SET")).trim();
            }
            return null;
        } catch (Exception e) {
            log.error("SqlUtils- 获取表名 异常",e);
            return null;
        }
    }

    /**
     * 分析sql的where条件
     * @param sql
     * @return
     */
    public static String analyzeSqlWhere(String sql) {
        try {
            String dml = getSqlDML(sql);
            // 忽略枚举表
            if(LogSqlConstant.DmlEnum.SELECT.equals(dml)
                    && LogSqlConstant.getIgnoreTable().contains(getTableName(sql))){
                return null;
            }

            if(LogSqlConstant.DmlEnum.UPDATE.equals(dml) || LogSqlConstant.DmlEnum.DELETE.equals(dml) || LogSqlConstant.DmlEnum.SELECT.equals(dml)){
                String sqlUpperCase = sql.toUpperCase();

                if(!sqlUpperCase.contains("WHERE")){
                    return "【高风险sql】"+dml+"无WHERE条件";
                }else {
                    String whereStr = sqlUpperCase.substring(sqlUpperCase.indexOf("WHERE")+5);
                    if(whereStr.contains("GROUP BY")){
                        whereStr = whereStr.substring(0,whereStr.indexOf("GROUP BY"));
                    }else if(whereStr.contains("ORDER BY")){
                        whereStr = whereStr.substring(0,whereStr.indexOf("ORDER BY"));
                    }
                    whereStr = whereStr.trim();
                    List<String> blList = Lists.newArrayList();
                    if(whereStr.contains("(")){
                        String[] bl = whereStr.split("\\(");
                        for (String b : bl) {
                            if(Func.isNotEmpty(b)){
                                blList.add(b);
                            }
                        }
                    }
                    List<String> brList = Lists.newArrayList();
                    for (String bl : blList) {
                        String[] br = bl.split("\\)");
                        for (String b : br) {
                            if(Func.isNotEmpty(b)){
                                brList.add(b);
                            }
                        }
                    }
                    List<String> andList = Lists.newArrayList();
                    for (String br : brList) {

                        String[] ands = br.split("AND");
                        for (String s : ands) {
                            if(Func.isNotEmpty(s)){
                                andList.add(s);
                            }
                        }
                    }

                    List<String> orList = Lists.newArrayList();
                    for (String an : andList) {
                        String[] ors = an.split("OR");
                        for (String s : ors) {
                            if(Func.isNotEmpty(s)){
                                orList.add(s);
                            }
                        }
                    }
                    StringBuilder nullSB = new StringBuilder();
                    for (String or : orList) {
                        String[] eqs = or.split("=");
                        if(eqs.length==2
                                && (Func.isEmpty(eqs[1]) || "null".equalsIgnoreCase(eqs[1].trim()) )){
                            nullSB.append(or).append(";");
                        }
                    }

                    return nullSB.length()>0?nullSB.insert(0,"【中风险sql】条件值为空:").toString():null;
                }
            }
            return null;
        } catch (Exception e) {
            log.error("SqlUtils-分析sql的where条件异常",e);
            return "SqlUtils-分析sql的where条件异常";
        }
    }


    public static void main(String[] args) {
//        System.out.println(getSqlDML("insertaass"));

        String sql0="select * from t_test where (sex='男' or sex='女' or id in (1) ) and name=null and id=2 and age in (1,2,3) group by dept order by id desc";
        String sql2="select day as day, code as code from t_day where day >= '2021-09-08' and day <= '2021-09-08' and (code = '0' or code = '2')";
        
//        String analyzeSqlWhere = analyzeSqlWhere(sql);
//        System.out.println(analyzeSqlWhere);

    }

}

LogSqlConstant.java
package com.xxx.xxx.xxx.model.log;

import com.google.common.collect.Sets;

import java.util.Set;

public class LogSqlConstant {

    public enum DmlEnum {
        SELECT,INSERT,UPDATE,DELETE;
    }

    public static Set<String> getIgnoreTable(){
        return Sets.newHashSet("T_PRIORITY","T_STATUS_TYPE","T_B_TYPE","T_A_TYPE");
    }
}

Func.java

package com.xxx.xxx.xxx.util;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 高频方法集合类
 */
public class Func {

    /**
     * 两个字符串数值 乘法
     *
     * @return
     */
    public static String multiply(String arg1, String arg2) {
        BigDecimal bg1 = new BigDecimal(arg1);
        BigDecimal bg2 = new BigDecimal(arg2);
        return bg1.multiply(bg2).toString();
    }

    /**
     * 比较两个对象是否相等。<br>
     * 相同的条件有两个，满足其一即可：<br>
     * 1. obj1 == null && obj2 == null; 2. obj1.equals(obj2)
     *
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否相等
     */
    public static boolean equals(Object obj1, Object obj2) {
        return (obj1 != null) ? (obj1.equals(obj2)) : (obj2 == null);
    }

    /**
     * 计算对象长度，如果是字符串调用其length函数，集合类调用其size函数，数组调用其length属性，其他可遍历对象遍历计算长度
     *
     * @param obj 被计算长度的对象
     * @return 长度
     */
//    public static int length(Object obj) {
//        return ObjectKit.length(obj);
//    }

    /**
     * 对象中是否包含元素
     *
     * @param obj     对象
     * @return 是否包含
     */
//    public static boolean contains(Object obj, Object element) {
//        return ObjectKit.contains(obj, element);
//    }

    public static boolean isNotEmpty(Object obj) {
        return !isEmpty(obj);
    }

    /**
     * 对象是否为空
     *
     * @param obj String,List,Map,Object[],int[],long[]
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj instanceof String) {
            if (obj.toString().trim().equals("")) {
                return true;
            }
        } else if (obj instanceof List) {
            if (((List) obj).size() == 0) {
                return true;
            }
        } else if (obj instanceof Map) {
            if (((Map) obj).size() == 0) {
                return true;
            }
        } else if (obj instanceof Set) {
            if (((Set) obj).size() == 0) {
                return true;
            }
        } else if (obj instanceof Object[]) {
            if (((Object[]) obj).length == 0) {
                return true;
            }
        } else if (obj instanceof int[]) {
            if (((int[]) obj).length == 0) {
                return true;
            }
        } else if (obj instanceof long[]) {
            if (((long[]) obj).length == 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 对象组中是否存在 Empty Object
     *
     * @param os 对象组
     * @return
     */
    public static boolean isOneEmpty(Object... os) {
        for (Object o : os) {
            if (isEmpty(o)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 对象组中是否全是 Empty Object
     *
     * @param os
     * @return
     */
    public static boolean isAllEmpty(Object... os) {
        for (Object o : os) {
            if (!isEmpty(o)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 是否为数字
     *
     * @param obj
     * @return
     */
    public static boolean isNum(Object obj) {
        try {
            Integer.parseInt(obj.toString());
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 数字是否为Null或Zero
     *
     * @param obj
     * @return
     */
    public static boolean isNullOrZero(Object obj) {
        if (obj == null) {
            return true;
        }

        if (obj instanceof Integer) {
            try {
                return Integer.parseInt(obj.toString()) == 0;
            } catch (Exception e) {
                return false;
            }
        }

        if (obj instanceof Long) {
            try {
                return Long.parseLong(obj.toString()) == 0L;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 如果为空, 则调用默认值
     *
     * @param str
     * @return
     */
    public static Object getValue(Object str, Object defaultValue) {
        if (isEmpty(str)) {
            return defaultValue;
        }
        return str;
    }

    /**
     * map的key转为小写
     *
     * @param map
     * @return Map<String   ,   Object>
     */
    public static Map<String, Object> caseInsensitiveMap(Map<String, Object> map) {
        Map<String, Object> tempMap = new HashMap<>();
        for (String key : map.keySet()) {
            tempMap.put(key.toLowerCase(), map.get(key));
        }
        return tempMap;
    }

    /**
     * 获取map中第一个数据值
     *
     * @param <K> Key的类型
     * @param <V> Value的类型
     * @param map 数据源
     * @return 返回的值
     */
    public static <K, V> V getFirstOrNull(Map<K, V> map) {
        V obj = null;
        for (Entry<K, V> entry : map.entrySet()) {
            obj = entry.getValue();
            if (obj != null) {
                break;
            }
        }
        return obj;
    }

    /**
     * 创建StringBuilder对象
     *
     * @return StringBuilder对象
     */
    public static StringBuilder builder(String... strs) {
        final StringBuilder sb = new StringBuilder();
        for (String str : strs) {
            sb.append(str);
        }
        return sb;
    }

    /**
     * 创建StringBuilder对象
     *
     * @return StringBuilder对象
     */
    public static void builder(StringBuilder sb, String... strs) {
        for (String str : strs) {
            sb.append(str);
        }
    }


    /**
     *  清除两边的空格
     * @param sql " aa bb cc "
     * @return "aa bb cc"
     */
    public static String clearSideSpaces(String sql) {
        if(Func.isEmpty(sql)){
            return "";
        }
        return sql.trim();
    }
    /**
     *  清除中间的空格
     * @param sql " aa bb
                    cc "

     * @return " aa bb cc "
     */
    public static String clearMiddleSpaces(String sql) {
        if(Func.isEmpty(sql)){
            return "";
        }
        return sql.replaceAll("[\\s]+", " ");
    }
    /**
     *  清除（两边+中间）的空格
     * @param sql " aa bb
                    cc "

     * @return "aa bb cc"
     */
    public static String clearExtraSpaces(String sql) {
        if(Func.isEmpty(sql)){
            return "";
        }
        return sql.replaceAll("[\\s]+", " ").trim();
    }

    public static void main(String[] args) {
        String sql = " aa bb cc ";
        System.out.println("--"+clearMiddleSpaces(sql)+"--");
    }
}

Peter-OK
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Spring Boot入门(23)：记录接口日志再也不难！用AOP和自定义注解给Spring Boot加上日志拦截器！
**My Coding Family**
09-01 3060
基于AOP实现自定义注解拦截接口日志并入库，一文教会你。
springboot异步和切面_SpringBoot强化篇（八）-- Spring AOP
weixin_42309599的博客
01-30 768
Spring AOP简介AOP(Aspect Orient Programming)是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如...
拦截mybatis执行的sql，并将sql插入到数据库中
qq_43043092的博客
03-03 3206
一、自定义mybatis的拦截器，获取mybatis执行的sql语句 @Intercepts({ @Signature(type = Executor.class, method = "update", args = { // type: 被拦截对象；method：要拦截对象的那个方法；args：需要哪些参数，method的入参 MappedStatement.class, Object.class})}) @Component public class My
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3599
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
最全面解析Spring框架IOC容器和AOP面向切面
tanning11627的博客
05-26 650
一、Spring开源框架的简介 Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。【参考文献】 它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java
第二天 ： AOP 面向切面编程 、 JdbcTemplete 工具类使用
cyh90的博客
11-09 461
AOP 面向切面编程 、 JdbcTemplete 工具类使用 目录 一、 什么是 AOP ***** 二、 AOP 的底层实现 1、 JDK动态代理 2、 使用CGlib 完成动态代理 三、 Spring AOP 1、 传统Spring AOP 提供 五类 Advice 2、 Spring 的切面  Advisor 3、案例一（不带切点的切面） ： 使用普通Advisor，...
13 AOP面向切面编程简单入门
BShu666的博客
10-15 409
简介 AOP是对OOP面向对象编程的一种补充和完善,可以不改变原有系统核心业务代码前提下,在对象运行时动态织入一些扩展功能和控制对象的执行. 代理机制 JDK代理: 底层采用JDK动态代理机制为目标对象创建代理对象(前提是目标类必须实现接口.最终代理类和目标类实现共同接口) CGLIB代理: 底层采用CGLIB代理机制为目标创建代理对象(不需要前提条件,最终代理类会继承目标对象类) 基本点简介 切面(aspect) :切面对象由@Aspect注解声明的类 通知(Advice):@Around,@Befor
AOP（面向切面编程） 及Mybatis简介
zhanglu1995的博客
06-23 1835
AOP（面向切面编程） AOP和OOP的比较 OOP语言提供了类与类之间纵向的关系（继承、接口），而AOP补充了横向的关系（比如在不改变目标类中源代码的情况下给com.john.demo.dao包下所有类中以insert和update开头的方法添加事务管理） AspectJ(切面) 我们将自己需要插入到目标业务逻辑中的代码模块化， 通过AOP使之可以横切多个类的模块，称之为切面。 在Spring ...
Spring (三) 之Aop及事务控制
最新发布
qq_45525848的博客
04-13 1012
Spring (三) 之Aop及事务控制
Spring mvc mybatis plus 实现AOP 切面日志系统
12-19
本项目“Spring MVC Mybatis Plus 实现AOP 切面日志系统”旨在提供一个基础的日志记录框架，能够自动追踪和记录应用程序的关键操作，同时支持数据持久化到数据库中，方便后期分析和问题排查。下面将详细介绍这些技术...
SSI框架搭建实例教程(struts spring ibatis整合 附切面事物处理)
10-11
接下来是Spring框架，它不仅提供了依赖注入（DI）和面向切面编程（AOP）的能力，还支持多种持久层技术，包括iBatis。Spring的DI使得对象之间的依赖关系可以通过配置文件或注解来管理，降低了代码的耦合度。AOP则允许...
Spring AOP应用
06-30
MyBatis是一个轻量级的持久层框架，而结合Spring AOP，我们可以实现更高级的功能，如事务管理、SQL日志记录、性能监控等。具体实现方式包括： 1. **MyBatis拦截器**：Spring AOP可以和MyBatis的拦截器机制结合，对...
原样输出mybatis的sql执行语句（mysql和oracle都可用）.zip
08-19
我们可以创建一个自定义的AOP切面，拦截MyBatis的SqlSession操作，记录并打印SQL语句。首先，定义一个切入点表达式，例如： ```java @Pointcut("execution(* org.apache.ibatis.session.defaults....
struts2+spring4+mybatis3，登录jquery ajax，struts拦截器，springAOP的例子
08-14
本项目示例涵盖了这些框架的整合使用，以及jQuery AJAX登录、Struts拦截器和Spring AOP（面向切面编程）的应用。 1. **Struts2**：Struts2是一个基于MVC（Model-View-Controller）设计模式的Web应用框架，它简化了...
使用EasyExcel报错NoClassDefFoundError: org/apache/poi/util/TempFileCreationStrategy，并不Easy
热门推荐
PeterOK的博客
12-29 3万+
最近项目中使用了alibaba的EasyExcel，结果报错抛出了Error，导致虽然 catch 了 Exception，然并卵。。。 首先来回顾一下JDK的API中对 Throwable、Exception和Error的解释： Throwable 类是 Java 语言中所有错误或异常的超类，其子类有Exception和Error。既然Error和Exception都是继承自Throwable，所以从根本上你可以理解他们是差不多的，程序出了问题就抛出。然后一般意义来讲，区别就是Error比Except
POST http://xxx net::ERR_NAME_NOT_RESOLVED 解决
PeterOK的博客
12-29 2万+
测试环境启动后，项目A前端访问项目B某接口报错 net::ERR_NAME_NOT_RESOLVED，F12，切到Network看到接口状态如下： 切换到Console看到状态如下： 怀疑是项目A、B服务器网络不通的问题，结果运维同事在项目A服务器上curl 项目B的接口，返回200，说明网络是通的。。。 百思不得其解，网上各种查询也没有相关答案，还以为是Docker机器里DNS解析的问题，，， 纠结了一下午，忽然想清楚了，在项目A服务器上curl 项目B的接口，返回200，说明项目A...
使用 p6spy，拦截到持久层执行的sql及参数
PeterOK的博客
09-27 1598
待完善
【Java】intern() 引发的问题-思考与解决
PeterOK的博客
11-04 1255
【举例解释】在调用”ab”.intern()方法的时候会返回”ab”，但是这个方法会首先检查字符串池中是否有”ab”这个字符串，如果存在则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然会返回这个字符串的引用。 在看如下两段程序 【程序一】 // 运行环境要 JDK7及以上 String s1 = new String("1"); ...
springAop切面
07-29
Spring AOP（Aspect-Oriented Programming）是Spring框架提供的一种面向切面编程的现方式。它允许开发人员将横切关注点（如日志记录、事务管理等）与核心业务逻辑进行分离，从而提高代码的可重用性和可维护性。 在Spring AOP中，通过定义切面（Aspect）来描述横切关注点，然后将切面与目标对象进行关联。切面可以通过配置文件或注解的方式进行声明。在运行时，Spring AOP会根据定义的切面规则自动将切面逻辑织入到目标对象的方法中。 切面由切点（Pointcut）和通知（Advice）组成。切点定义了在哪些方法上应用切面逻辑，通知定义了切面逻辑的具体实现。通知可以在目标方法执行前、执行后、抛出异常时等不同的时机触发。 常见的通知类型包括： - 前置通知（Before Advice）：在目标方法执行前执行； - 后置通知（After Advice）：在目标方法执行后执行，无论是否发生异常； - 返回通知（After Returning Advice）：在目标方法执行后执行，仅在目标方法成功返回时触发； - 异常通知（After Throwing Advice）：在目标方法抛出异常后执行； - 环绕通知（Around Advice）：在目标方法执行前后都执行，可以控制目标方法的执行流程。 Spring AOP可以应用于各个层面，如业务逻辑、数据访问、事务管理等，通过将横切关注点与核心业务逻辑解耦，可以提高代码的模块化和可维护性。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值