切面更改入参

定义一个注解 

package com.huaxia.bigdata.bi.common.annotation;


import com.zeekr.bigdata.bi.common.constant.Constant;
import com.zeekr.bigdata.bi.common.enums.MetadataTypeEnum;
import com.zeekr.bigdata.bi.common.enums.SeriesTypeEnum;
import org.springframework.validation.annotation.Validated;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 将code拆分出来
 * @author sol
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
public @interface SplitParam {

    /**
     * 分隔符，默认为英文逗号
     */
    String separativeSign() default Constant.SEPARATIVE_SIGN_COMMA;
}

切面类，将参数里面的字段进行拆分

package com.huaxia.bigdata.bi.common.aop;


import com.zeekr.bigdata.bi.common.annotation.SplitParam;
import com.zeekr.bigdata.bi.common.constant.Constant;
import com.zeekr.bigdata.bi.common.util.StringUtil;
import com.zeekr.bigdata.bi.privilege.annotation.RowPrivilegeProperty;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;

/**
 * 对请求参数进行校验
 *
 * @author: sol
 * @date: 2023/3/28 15:40
 */
@Slf4j
@Aspect
@Component
public class ParameterCheckAspect {


//    @Pointcut("@within(com.zeekr.bigdata.bi.common.annotation.SplitParam)")
//    public void pointcutWithin(){
  //  }
 
 //   @Around("pointcutWithin()") 


    @Around("execution(* com.zeekr.bigdata.bi..*.controller..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 内部 访问不进行校验
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        if (null == requestAttributes) {
            return joinPoint.proceed();
        }
        if (joinPoint.getArgs().length == 0) {
            return joinPoint.proceed();
        }
        // 获取拦截方法的第一个参数
        Object inParam = joinPoint.getArgs()[0];

        Set<String> fieldNameSet = new HashSet<>(16);
        Set<Field> fieldList = new HashSet<>(16);
        Class<?> doClass = inParam.getClass();
        // 考虑父类和子类会有相同的字段，所以在这做一层过滤
        while (doClass != Object.class) {
            ReflectionUtils.doWithFields(doClass, field -> {
                if (fieldNameSet.add(field.getName())) {
                    fieldList.add(field);
                }
            });
            doClass = doClass.getSuperclass();
        }
        for (Field field : fieldList) {
            SplitParam annotation = field.getAnnotation(SplitParam.class);
            if (null != annotation) {
                splitParam(inParam, field, annotation.separativeSign());
            } else if ("carTypeList".equals(field.getName())) {
                // carTypeList没有添加注解，所以需要单独处理
                splitParam(inParam, field, Constant.SEPARATIVE_SIGN_COMMA);
            }
        }

        return joinPoint.proceed();

    }


    /**
     * 将code以逗号为间隔拆分出来
     *
     * @param field
     * @param separativeSign
     * @author: e-Yuanhui.Ji
     * @date: 2023/8/15 18:24
     */
    private static void splitParam(Object obj, Field field, String separativeSign) {
        try {
            Class clazz = obj.getClass();
            // 将字段访问设置为真
            field.setAccessible(true);
            // 判断是否为集合类型
            if (field.getType().equals(List.class)) {
                // 获取字段真实类型，直接将field强转为List行不通
               // Method m = clazz.getMethod("get" + StringUtil.firstToUpper(field.getName()));

               // List<String> inputList = (List<String>) m.invoke(obj);


                List<String> inputList =  (List<String>)field.get(obj);
                // 如果参数为空则将字典表里面的数据填充进去
                List<String> resultList = null;
                if (CollectionUtils.isNotEmpty(inputList)) {
                    resultList = new ArrayList<>(16);
                    for (String item : inputList) {
                        if (StringUtils.isBlank(item)) {
                            continue;
                        }
                        resultList.addAll(Arrays.asList(item.split(separativeSign)));
                    }
                }
                field.set(obj, resultList);
            }
        } catch (Exception e) {
            log.error("BaseRequestAspect.checkCarTypeList() exception => 【inParam = {}】, 【fieldName = {}】", obj, field.getName(), e);
        }
    }

 
}