使用AOP记录feign调用日志

Khazix

已于 2024-03-20 17:32:18 修改

阅读量671

点赞数 11

于 2024-03-20 17:24:54 首次发布

本文链接：https://blog.csdn.net/Khazix/article/details/136882843

版权

微服务相关专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

业务场景
使用
- DemoClientFeign
- DemoFeignFallBack
主要代码

业务场景

记录请求第三方接口的情况。@DockLog可以用在类上也可以用在方法上

使用

DemoClientFeign


import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * DemoClientFeign
 *
 * @since 2024-03-12
 */
@DockLog
@FeignClient(url = "http://127.0.0.1:9707/demo_api", name = "demoClientFeign",
        fallbackFactory = DemlFeignFallBack.class)
public interface DemoClientFeign {

    /**
     * 获取token
     */
    @PostMapping(value = "/auth/login", produces = {MediaType.APPLICATION_JSON_VALUE})
    String getToken(@RequestBody String body);
}

DemoFeignFallBack


import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class DemlFeignFallBack implements FallbackFactory<DemoClientFeign> {

	@Override
    public DemlFeignFallBack create(Throwable throwable) {

        log.error("DemoClientFeign error", throwable);

        return new DemoClientFeign() {
            @Override
            public String getToken(String body) {
                return null;
            }
		}
	}
}

主要代码

DockLogAspect


import com.xxx.JacksonUtils;
import com.xxx.DockLogAddDTO;
import com.xxx.DockLogService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import java.lang.reflect.Method;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;

/**
 * 三方feign请求-日志记录
 *
 * @since 2024/3/19 15:50
 */
@Aspect
@Component
@Slf4j
public class DockLogAspect {

    @Autowired
    private DockLogService dockLogService;
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    private final ThreadLocal<DockLogAddDTO> tl = new ThreadLocal<>();

    @Pointcut("@within(com.ccreate.cnpc.openapi.annotations.DockLog) || @annotation(com.ccreate.cnpc.openapi.annotations.DockLog)")
    public void pointcut() {
    }

    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {
        DockLogAddDTO addDTO = tl.get();
        if (addDTO == null) {
            addDTO = new DockLogAddDTO();
        }

        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        PostMapping postMapping = method.getAnnotation(PostMapping.class);
        GetMapping getMapping = method.getAnnotation(GetMapping.class);
        RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);

        if (postMapping == null && getMapping == null && requestMapping == null) {
            return;
        }

        String[] value = new String[]{};
        if (Objects.nonNull(postMapping)) {
            value = postMapping.value();
        }
        if (Objects.nonNull(getMapping)) {
            value = getMapping.value();
        }
        if (Objects.nonNull(requestMapping)) {
            value = requestMapping.value();
        }
        if (value.length == 0) {
            return;
        }

        Object[] args = joinPoint.getArgs();

        addDTO.setStartMillis(System.currentTimeMillis());
        addDTO.setRequest(JacksonUtils.toJson(args));
        addDTO.setUrl(joinUrl(value[0], methodSignature));

        tl.set(addDTO);
    }

    @AfterReturning(value = "pointcut()", returning = "obj")
    public void afterReturn(Object obj) {
        try {
            DockLogAddDTO addDTO = tl.get();
            if (Objects.isNull(addDTO)) {
                return;
            }

            // 异步保存
            CompletableFuture.runAsync(() -> {
                if (Objects.nonNull(obj)) {
                    addDTO.setSuccess(true);
                    addDTO.setResponse(JacksonUtils.toJson(obj));
                } else {
                    addDTO.setSuccess(false);
                }
                addDTO.setCompletedMillis(System.currentTimeMillis());
                // 保存
                dockLogService.add(addDTO);
            }, taskExecutor);
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            tl.remove();
        }
    }

    @AfterThrowing(pointcut = "pointcut()", throwing = "t")
    public void afterThrowing(JoinPoint jp, Throwable t) {
        try {
            DockLogAddDTO addDTO = tl.get();
            if (Objects.isNull(addDTO)) {
                return;
            }

            // 异步保存
            CompletableFuture.runAsync(() -> {
                addDTO.setSuccess(false);
                addDTO.setResponse(ExceptionUtils.getStackTrace(t));
                addDTO.setCompletedMillis(System.currentTimeMillis());
                // 保存
                dockLogService.add(addDTO);
            }, taskExecutor);
        } catch (Exception e) {
            log.error("afterThrowing exception", e);
        } finally {
            tl.remove();
        }
    }

    /**
     * 拼接URL
     */
    public String joinUrl(String url, Signature signature) {
        FeignClient feignClient = AnnotationUtils.findAnnotation(signature.getDeclaringType(), FeignClient.class);
        if (Objects.isNull(feignClient)) {
            return url;
        }

        return feignClient.url() + url;
    }
}

DockLog


import java.lang.annotation.*;

/**
 * 日志记录
 *
 * @since 2024/3/19 15:49
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DockLog {

}

DockLogService


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 三方接口feign请求日志 自定义服务实现类
 */
@Slf4j
@Service
public class DockLogService {

    /**
     * 新增三方接口feign请求日志
     *
     * @param params 三方接口feign请求日志信息
     * @author pengjin 2024-03-19
     */
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(DockLogAddDTO params) {

        // 参数转成实体PO
        DockLogPO dockLogPo = CommonUtils.copyProperties(params, DockLogPO.class);

        Long startMillis = params.getStartMillis();
        Long completedMillis = params.getCompletedMillis();
        if (ObjectUtils.allNotNull(startMillis, completedMillis)) {
            dockLogPo.setTimeConsuming(completedMillis - startMillis);
        }

        return iDockLogService.save(dockLogPo);
    }
}

DockLogAddDTO


import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;

/**
 * 三方接口feign请求日志
 */
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "三方接口feign请求日志新增参数对象", description = "三方接口feign请求日志")
public class DockLogAddDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "id")
    private Long id;

    @ApiModelProperty(value = "请求")
    private String url;

    @ApiModelProperty(value = "请求参数")
    private String request;

    @ApiModelProperty(value = "返回参数")
    private String response;

    @ApiModelProperty(value = "是否成功:1-成功,0-未成功")
    private Boolean success;

    @ApiModelProperty(value = "请求耗时:毫秒")
    private Long timeConsuming;

    @ApiModelProperty(value = "请求开始时间")
    private Long startMillis;

    @ApiModelProperty(value = "请求结束时间")
    private Long completedMillis;
}

JacksonUtils


import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.json.JsonWriteFeature;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * JacksonUtils
 *
 * @author pengjin 2022/9/5
 * @see com.alibaba.nacos.common.utils.JacksonUtils
 */
@Slf4j
public final class JacksonUtils {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    static {
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        // 序列化配置,针对java8 时间
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));

        // 反序列化配置,针对java8 时间
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));

        MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                .registerModules(javaTimeModule)
                .configure(JsonWriteFeature.QUOTE_FIELD_NAMES.mappedFeature(), true);
    }

    /**
     * Object to json string
     */
    public static String toJson(Object obj) {
        try {
            return MAPPER.writeValueAsString(obj);
        } catch (IOException e) {
            log.error("toJson error", e);
            throw E.of(BaseExceptionEnum.FORMAT_ERROR);
        }
    }

    /**
     * Json string deserialize to Jackson {@link JsonNode}.
     *
     * @param json json string
     * @return {@link JsonNode}
     */
    public static JsonNode toObj(String json) {
        try {
            return MAPPER.readTree(json);
        } catch (IOException e) {
            log.error("转JsonNode失败", e);
            throw E.of(BaseExceptionEnum.FORMAT_ERROR);
        }
    }

    /**
     * Json string deserialize to Object.
     *
     * @param json          json string
     * @param typeReference {@link TypeReference} of object
     * @param <T>           General type
     * @return object
     * @throws E if deserialize failed
     */
    public static <T> T toObj(String json, TypeReference<T> typeReference) {
        try {
            return MAPPER.readValue(json, typeReference);
        } catch (IOException e) {
            log.error("toObj error", e);
            throw E.of(BaseExceptionEnum.FORMAT_ERROR);
        }
    }

    /**
     * Json string deserialize to Object.
     *
     * @param json json string
     * @param type type of object
     * @param <T>  General type
     * @return object
     * @throws E if deserialize failed
     */
    public static <T> T toObj(String json, Class<T> type) {
        try {
            return MAPPER.readValue(json, type);
        } catch (IOException e) {
            log.error("toObj error", e);
            throw E.of(BaseExceptionEnum.FORMAT_ERROR);
        }
    }

    /**
     * Parse object to Jackson {@link JsonNode}.
     */
    public static JsonNode transferToJsonNode(Object obj) {
        return MAPPER.valueToTree(obj);
    }

    /**
     * Parse object to Jackson {@link ObjectNode}.
     */
    public static ObjectNode transferToObjectNode(Object obj) {
        return transferToJsonNode(obj).deepCopy();
    }

    /**
     * Parse object to Jackson {@link ObjectNode}.
     */
    public static ObjectNode transferToObjectNode(String json) {
        return toObj(json).deepCopy();
    }

    private JacksonUtils() {

    }
}