java 拦截referer JAVA 拦截打印

转载

clghxq 2023-09-05 10:50:55

文章标签 java 拦截referer java spring AOP 文章分类 Java 后端开发

为了熟悉AOP中的ASPECTJ的使用，为了方便我们在写数据搬运型代码时候观测的方便，自己学习并定义了一组切面方法和注解，来实现这个功能，啥都不说了，先上代码：

首先是注解定义：

import java.lang.annotation.*;

/**
 * @author wangxiao
 * @date 2020-05-26 10:38
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
@Documented
public @interface ServiceAroundLog {

    /**
     * 定义方法名称
     * @return
     */
    String methodName() default "";

    /**
     * 是否打印方法执行时间
     * @return
     */
    boolean isTimeInterval() default true;

    /**
     * 是否打印方法参数
     * @return
     */
    boolean isPrintParam() default true;

}

注解定义完成之后，我们开始定义使用这个注解的切面方法：

import com.alibaba.fastjson.JSON;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;

/**
 * @author wangxiao
 * @date 2020-05-26 10:50
 */
@Aspect
@Order(2)
@Component
public class ServiceAroundLogAspect {

    @Around("@annotation(ServiceAroundLog)")
    public Object beforeReturnValue(ProceedingJoinPoint point) throws Throwable {
        Method methodSignart = ((MethodSignature) point.getSignature()).getMethod();
        ServiceAroundLog methodAnnotation = methodSignart.getAnnotation(ServiceAroundLog.class);

        if (methodAnnotation != null) {

            Logger logger = LoggerFactory.getLogger(point.getThis().getClass());
            boolean isTimeInterval = methodAnnotation.isTimeInterval();
            String name = methodAnnotation.methodName();
            if (StringUtils.isEmpty(name)) {
                name = methodSignart.getName();
            }
            logger.info("----------方法{}开始执行----------", name);
            long s = 0;
            if (isTimeInterval) {
                s = System.currentTimeMillis();
            }

            boolean isPrintParam = methodAnnotation.isPrintParam();

            if (isPrintParam) {
                Parameter[] parameters = methodSignart.getParameters();
                Object[] args = point.getArgs();
                if (parameters != null || parameters.length > 0) {
                    StringBuilder sb = new StringBuilder();
                    sb.append("方法参数列表：[");
                    for (int i = 0; i < parameters.length; i++) {
                        sb.append("{参数名：");
                        sb.append(parameters[i].getName());
                        sb.append("-");
                        sb.append("值：");
                        sb.append(parameters[i] == null ? "null" : JSON.toJSONString(args[i]));
                        sb.append("}");
                    }
                    sb.append("]");
                    logger.info(sb.toString());
                }
            }

            Object proceed = point.proceed();
            // 返回值为list类型，打印返回值list数量
            if (proceed instanceof ArrayList) {
                final List list = (List) proceed;
                logger.info("-----返回值为list集合，大小为：{}-----", list.size());
            }

            if (isTimeInterval) {
                logger.info("--------方法{}执行耗时：{}ms--------", name, (System.currentTimeMillis() - s));
            }
            logger.info("----------方法{}执行结束----------", name);
            return proceed;
        }

        return point.proceed();
    }
}

这样当我们在要使用的方法上打上@ServiceAroundLog注解的时候，他就会在方法执行的时候，打印方法执行的日志了。

java 拦截referer JAVA 拦截打印_spring