基于自定义注解+事件发布与监听+面相切面编程实现日志采集

Myth丶恋晨 2022-10-06 01:50 103阅读 0赞

# 1、自定义注解 #

LogRecord

<table> 
 <tbody> 
  <tr> 
   <th> <pre><code>import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 记录请求日志
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LogRecord {
    /**
     * 功能名称
     */
    String modelName();

/**
     * 操作类型
     */
    String operate();

/**
     * 匹配
     * 示例
     * [0] 第一个参数
     * [0].name 第一个参数的name属性值
     * [0].[name] 第一个参数，类型是数组，每个单元的name属性值
     * [0].ito.name 第一个参数，其中ito属性下的name属性值
     * [0].list.[id] 第一个参数，其中list属性下的id属性值
     */
    String patterns() default "";

/**
     * 日志类型
     * 1、操作日志
     * 2、操作日志+业务日志
     */
    int logType() default 1;

}
</code></pre> </th> 
  </tr> 
 </tbody> 
</table>

# 2、织入点 #

<table> 
 <tbody> 
  <tr> 
   <th> <pre><code>@ApiOperation(value = "根据id查询客户信息表")
@LogRecord(modelName = "客户信息", operate = OperateType.GET)
@PostMapping("/get/{id}")
public Responses&lt;CustomerOTO&gt; getOne(@PathVariable Long id) {
    CustomerOTO data = remoteCustomerService.getOne(id);
    if (null != data) {
        data.setMobile(EncryptionUtils.getPhone(data.getMobile()));
        data.setIdCard(EncryptionUtils.getIdCard(data.getIdCard()));
    }
    return Responses.success(data);
}

@ApiOperation(value = "修改跟进状态")
@PostMapping("/update/{id}")
@LogRecord(modelName = "客户信息", operate = OperateType.UPDATE, logType = 2, patterns = "[1].name")
public Responses update(@PathVariable Long id, @Validated @RequestBody CustomerUpdateITO ito) {
    remoteCustomerService.update(id, ito);
    return Responses.success();
}</code></pre> </th> 
  </tr> 
 </tbody> 
</table>

# 3、日志切面 #

<table> 
 <tbody> 
  <tr> 
   <th> <pre><code>package com.picc.vx.portal.config;

import com.alibaba.fastjson.JSON;
import com.picc.common.util.annotation.LogRecord;
import com.picc.common.util.enums.SystemEnum;
import com.picc.common.util.obj.ObjectFiledUtils;
import com.picc.common.util.user.UserUtils;
import com.picc.common.util.vo.auth.SystemUser;
import com.picc.vx.portal.service.mail.SendMailService;
import com.picc.vx.portal.util.IPUtils;
import com.picc.vx.report.service.api.ito.LogAddITO;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.OutputStream;
import java.lang.reflect.Method;

/**
 * 项目日志 切面
 */
@Aspect
@Component
public class WebLogAspect {

private static final Logger log = LoggerFactory.getLogger(WebLogAspect.class);

@Autowired
    private ApplicationEventPublisher publisher;

@Resource
    private SendMailService sendMailService;

/**
     * 统计时间
     */
    ThreadLocal&lt;Long&gt; startTime = new ThreadLocal&lt;&gt;();

@Pointcut("@annotation(com.picc.common.util.annotation.LogRecord)")
    public void webLog() {
    }

@Before("webLog()")
    public void doBefore() {
        startTime.set(System.currentTimeMillis());
    }

@AfterReturning(returning = "res", pointcut = "webLog()")
    public void doAfterReturning(JoinPoint joinPoint, Object res) {
        String url = "";
        String requestBody = "";
        // 接收到请求，记录请求内容
        try {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();

MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();

LogRecord logRecord = method.getAnnotation(LogRecord.class);
            if (null == logRecord) {
                return;
            }
            //请求响应信息
            Object[] args = joinPoint.getArgs();
            String value = ObjectFiledUtils.getValue(logRecord.patterns(), args);

String ip = IPUtils.getIp(request);
            String uri = getUri(joinPoint, method);
            url = request.getRequestURI();
            Long consumeTime = System.currentTimeMillis() - startTime.get();
            Object[] req = new Object[joinPoint.getArgs().length];
            for (int i = 0; i &lt; joinPoint.getArgs().length; i++) {
                Object obj = joinPoint.getArgs()[i];
                if (obj instanceof MultipartFile || obj instanceof ServletResponse || obj instanceof ServletRequest
                        || obj instanceof HttpSession) {
                    continue;
                }
                req[i] = obj;
            }
            if (req.length &gt; 0) {
                requestBody = JSON.toJSONString(req);
            }
            String responseBody = "";
            if (!(res instanceof OutputStream || res instanceof ResponseEntity)) {
                responseBody = JSON.toJSONString(res);
            }

//获取注解中的值
            String model = logRecord.modelName();
            String operate = logRecord.operate();

//登录用户信息
            SystemUser userInfo = UserUtils.getUserInfo();
            Long employeeId = null;
            String employeeName = "未登录的测试者";
            Long tenantCode = -1L;
            String tenantName = "未登录的测试租户";
            if (null != userInfo) {
                employeeId = userInfo.getId();
                employeeName = userInfo.getName();
                tenantCode = userInfo.getTenantCode();
                tenantName = userInfo.getTenantName();
            }
            //操作详细信息
            if (StringUtils.isNotBlank(value)) {
                value = "：" + value;
            }
            String content = "【" + operate + "】" + model + value;

LogAddITO ito = new LogAddITO(SystemEnum.PORTAL.getType(), SystemEnum.PORTAL.getDesc(), tenantCode, tenantName,
                    model, "", operate, content, employeeId, employeeName, consumeTime, ip,
                    uri, url, requestBody, responseBody, logRecord.logType());

publisher.publishEvent(ito);
        } catch (Exception e) {
            String msg = url + "，异常：" + e.getMessage() + "," + e;
            sendMailService.sendLogError(msg, requestBody);
            log.error("记录日志失败：" + e.getMessage(), e);
        }
    }

private String getUri(JoinPoint joinPoint, Method method) {
        String uri = "";
        RequestMapping requestMapping = joinPoint.getTarget().getClass().getDeclaredAnnotation(RequestMapping.class);
        if (null != requestMapping) {
            uri = requestMapping.value()[0];
        }

String subUri = "";

PostMapping postMapping = method.getAnnotation(PostMapping.class);
        if (null != postMapping) {
            subUri = postMapping.value()[0];
            return uri + subUri;
        }
        GetMapping getMapping = method.getAnnotation(GetMapping.class);
        if (null != getMapping) {
            subUri = getMapping.value()[0];
            return uri + subUri;
        }
        PutMapping putMapping = method.getAnnotation(PutMapping.class);
        if (null != putMapping) {
            subUri = putMapping.value()[0];
            return uri + subUri;
        }

DeleteMapping deleteMapping = method.getAnnotation(DeleteMapping.class);
        if (null != deleteMapping) {
            subUri = deleteMapping.value()[0];
            return uri + subUri;
        }

return uri + subUri;
    }

}</code></pre> </th> 
  </tr> 
 </tbody> 
</table>

# 4、事件监听 #

<table> 
 <tbody> 
  <tr> 
   <th> <pre><code>package com.picc.vx.portal.event;

import com.picc.vx.report.service.api.feign.RemoteBusinessLogService;
import com.picc.vx.report.service.api.ito.LogAddITO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Slf4j
@Component
public class LogListener {

@Resource
    private RemoteBusinessLogService remoteBusinessLogService;

@EventListener
    public void onApplicationEvent(LogAddITO event) {
        try {
            remoteBusinessLogService.add(event);
        } catch (Exception e) {
            log.error("保存业务日志失败", e);
        }
    }

}</code></pre> </th> 
  </tr> 
 </tbody> 
</table>

# 5、线程池 #

<table> 
 <tbody> 
  <tr> 
   <th> <pre><code>package com.picc.vx.portal.config;

import com.picc.common.spring.util.RedisLockHelper;
import com.picc.common.spring.util.RetryHelper;
import com.picc.common.spring.util.jmx.MBeanThreadPoolMonitor;
import com.picc.common.spring.util.jmx.TomcatConnectorMonitor;
import com.picc.common.util.jmx.ExecutorCollections;
import com.picc.common.util.jmx.executor.ThreadPoolTaskExecutorMonitor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * @program: picc-vx-portal-system
 * @description: 线程池
 * @author: Liuxd
 * @create: 2020-05-15 10:00
 **/
@Configuration
@EnableAsync(proxyTargetClass = true)
@EnableScheduling
public class ExecutorConfig {
    @Primary
    @Bean("executor")
    public ThreadPoolTaskExecutor asyncServiceExecutor() {
        ThreadPoolTaskExecutorMonitor executor = new ThreadPoolTaskExecutorMonitor();
        executor.setPoolName("async-system");
        //配置核心线程数
        executor.setCorePoolSize(10);
        //配置最大线程数
        executor.setMaxPoolSize(20);
        //配置队列大小
        executor.setQueueCapacity(10000);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("async-system-");

// rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

@Bean
    public TomcatConnectorMonitor tomcatConnectorCustomizer() {
        return new TomcatConnectorMonitor();
    }

@Bean("dbExecutor")
    public ThreadPoolTaskExecutor asyncDbServiceExecutor() {
        ThreadPoolTaskExecutorMonitor executor = new ThreadPoolTaskExecutorMonitor();
        executor.setPoolName("async-db");
        //配置核心线程数
        executor.setCorePoolSize(10);
        //配置最大线程数
        executor.setMaxPoolSize(20);
        //配置队列大小
        executor.setQueueCapacity(10000);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("async-db-");
        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

@Bean(AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME)
    public ApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executor) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.setTaskExecutor(executor);
        return multicaster;
    }

@Bean("scheduler")
    public ThreadPoolTaskScheduler initThreadPoolTaskScheduler() {
        ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
        executor.setThreadNamePrefix("Scheduler-");
        executor.setPoolSize(5);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

@Bean
    public RetryHelper initRetryHelper(ThreadPoolTaskExecutor executor, ThreadPoolTaskScheduler scheduler) {
        return new RetryHelper(executor, scheduler);
    }

@Bean
    public RedisLockHelper initRedisLockHelper(RedisTemplate redisTemplate) {
        return new RedisLockHelper(redisTemplate);
    }

@Bean
    public MBeanThreadPoolMonitor initMBeanThreadPoolMonitor(ThreadPoolTaskScheduler scheduler,
                                                             @Qualifier("executor") ThreadPoolTaskExecutor system,
                                                             @Qualifier("dbExecutor") ThreadPoolTaskExecutor db) {
        ExecutorCollections.addExecutor(system);
        ExecutorCollections.addExecutor(db);
        return new MBeanThreadPoolMonitor(scheduler);
    }
}

</code></pre> </th> 
  </tr> 
 </tbody> 
</table>