基于Spring AOP的Log收集汇总_开发_开发者

前情提要

张三对于公司的日志处理系统不满意，认为其性能不佳且功能有限。为了展示自己的能力和技术实力，他决定利用Spring AOP（面向切面编程）开发一个更高效的日志处理系统，并将其存储在Redis中。

首先，张三分析了现有日志处理系统的不足之处，如性能瓶颈、日志格式不统一、存储容量有限等。然后，他开始着手设计和实现一个新的日志处理系统。

使用Spring AOP进行日志拦截：张三利用Spring AOP的切面功能，为需要记录日志的方法添加了一个切面。在这个切面中，他可以捕获方法的调用信息，如方法名、参数、返回值等，并将这些信息作为日志内容。

日志格式化：为了确保日志的一致性和可读性，张三设计了一种统一的日志格式。他将日志分为不同的级别，如DEBUG、INFO、WARN和ERROR，并为每个级别设置了不同的颜色和标签。

Redis存储：张三选择将日志存储在Redis中，因为Redis是一个高性能的键值存储系统，适合存储大量的日志数据。他为每个日志级别创建了一个Redis列表，用于存储相应级别的日志。同时，他还设置了一个定时任务，定期清理过期的日志数据，以保持存储空间的整洁。

监控与告警：为了方便监控日志系统的运行状况，张三还开发了一个简单的监控界面，可以实时查看各个日志级别的数量、存储空间使用情况等信息。此外，他还设置了一些告警规则，当某个日志级别的数量超过阈值时，会自动发送告警通知给相关人员。

经过一段时间的努力，张三成功地完成了这个基于Spring AOP的日志处理系统，并将其部署到了生产环境。公司同事对他的工作表示赞赏，认为这个新的日志处理系统不仅提高了性能，还提供了更多有用的功能。这无疑突显了张三的技术能力和对公司的贡献。

以下是一个简化的代码实现示例，展示了如何使用Spring AOP和Redis来实现日志处理系统。

场景实现

创建一个日志切面类**LoggingASPect**

在此过程中，我们创建了一个日志切面类LoggingAspect，它会拦截指定包路径下的所有方法调用。在方法调用完成后，它会将方法的调用信息（如方法名、参数、返回值等）作为日志内容，并将这些信息传递给LogService进行处理。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
    @Autowired
    private LogService logService;
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void logPointcut() {}
    @AfterReturning(pointcut = "logPointcut()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        logService.log(joinPoint, result);
    }
}

创建一个日志服务类**LogService****：**

LogService负责将日志内容存储到Redis中。在这个示例中，我们使用了RedisTemplate来操作Redis。我们将日志内容存储在名为log的Redis列表中。

import org.aspectj.lang.JoinPoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class LogService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    public void log(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        String logMessage = String.format("Method: %s, Args: %s, Result: %s", methodName, Arrays.toString(args), result);
        // 将日志存储到Redis
        redisTemplate.opsForList().rightPush("log", logMessagphpe);
    }
}

还可以为不同级别的日志创建不同的Redis列表：

public class LogService {
    // ...
    public void log(JoinPoint joinPoint, Object result, LogLevel logLevel) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        String logMessage = String.format("Method: %s, Args: %s, Result: %s", methodName, Arrays.toString(args), result);
        // 根据日志级别将日志存储到不同的Redis列表中
        String redisKey = "log:" + logphpLevel.name().toLowerCase();
        redisTemplate.opsForList().rightPush(redisKey, logMessage);
    }
}

也可以修改日志格式化：

public class LogService {
    // ...
    public void log(JoinPoint joinPoint, Object result, LogLevel logLevel) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        String logMessage = String.format("[%s] Method: %s, Args: %s, Result: %s", logLevel, methodName, Arrays.toString(args), result);
        // 根据日志级别将日志存储到不同的Redis列表中
        String redisKey = "log:" + logLevel.name().toLowerCase();
        redisTemplate.opsForList().rightPush(redisKey, logMessage);
    }
}

配置RedisTemplate：

最后，我们配置了一个RedisTemplate Bean，用于序列化和反序列化Redis的key和value值。这样，我们就可以将日志内容以结构化的方式存储在Redis中，并在需要时方便地进行查询和分析。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2jsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        template.setValueSerializer(genericJackson2JsonRedisSerializer);
        template.setHashValueSQHnZYsxerializer(genericJackson2JsonRedisSerializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSphperializer);
        template.afterPropertiesSet();
        return template;
    }
}

定时任务：

我们创建了一个定时任务LogCleanupTask，它会定期清理过期的日志数据。我们使用了Spring的@Scheduled注解来实现定时任务，并使用RedisTemplate来操作Redis。在cleanupLogs方法中，我们遍历所有的日志列表，并根据日志的时间戳判断它们是否过期。如果过期，则将其从Redis中移除。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class LogCleanupTask {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Scheduled(cron = "0 0 * * * ?") // 每小时执行一次
    public void cleanupLogs() {
        // 清理过期的日志数据，例如保留最近7天的日志
        String redisKeyPattern = "log:*";
        Set<String> keys = redisTemplate.keys(redisKeyPattern);
        for (String key : keys) {
            List<Object> logs = redisTemplate.opsForList().range(key, 0, -1);
            List<Object> logsToRemove = logs.stream()
                    .filter(log -> isExpired(log))
                    .collect(Collectors.toList());
            redisTemplate.opsForList().remove(key, 0, logsToRemove);
        }
    }
    private boolean isExpired(Object log) {
        // 判断日志是否过期，例如根据日志的时间戳和当前时间进行比较
        // ...
    }
}

监控界面：

我们创建了一个监控界面LogMonitorController，它可以实时查看日志数据。我们使用了Spring的@RestController注解来创建一个RESTful API，并使用RedisTemplate来操作Redis。在getLogs方法中，我们遍历所有的日志列表，并将它们以JSON格式返回给客户端。客户端可以使用这些数据来实时监控日志系统的运行状况。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class LogMonitorController {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @GetMapping("/monitor/logs")
    public Map<String, Object> getLogs() {
        Map<String, Object> logs = new HashMap<>();
        String redisKeyPattern = "log:*";
        Set<String> keys = redisTemplate.keys(redisKeyPattern);
        for (String key : keys) {
            List<Object> logList = redisTpythonemplate.opsForList().range(key, 0, -1);
            logs.put(key, logList);
        }
        return logs;
    }
}

❗❗❗ 请注意！！！ 这个示例仅用于演示如何使用Spring AOP和Redis实现日志处理系统。在实际项目中，需要根据具体需求进行更多的定制和优化。例如，可以为不同级别的日志创建不同的Redis列表，以便更好地管理和查询日志数据。此外，还可以考虑使用更高级的日志框架，如Logback或Log4j2，以实现更丰富的日志功能和更好的性能。

Get知识点

AOP概念：AOP（面向切面编程）是一种编程范式，它允许开发者在不修改原有代码的情况下，对程序的某些方面进行增强。AOP通过将横切关注点（如日志记录、事务管理、权限控制等）与业务逻辑分离，使得代码更加模块化和可维护。

Spring AOP：Spring AOP是Spring框架中的一个重要组件，它提供了声明式的AOP支持。Spring AOP使用代理模式来实现AOP，可以通过JDK动态代理或CGLIB代理来创建代理对象。Spring AOP支持多种类型的切面，如前置通知、后置通知、异常通知、环绕通知等。

@Aspect — 此注释将类定义为一个方面，即关注点的模块化。该方面包含建议和要点。
@Joinpoint — 连接点是程序执行中可以应用方面的一个点。在 Spring AOP 中，连接点是方法调用。
@Advice — 建议是某个方面在特定连接点上采取的行动。有几种类型的建议，例如“之前”、“之后”、“周围”等。
@Pointcut — 切点是一组应应用方面的连接点。它定义了一个模式，该模式与方面应截获的方法相匹配。可以使用表达式或注释来定义切点。

下面是 Spring AOP 注解的示例：

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(public * com.example.myapp.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before " + joinPoint.getSignature().getName() + " method");
    }
    @After("execution(public * com.example.myapp.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After " + joinPoint.getSignature().getName() + " method");
    }
    @Around("execution(public * com.example.myapp.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before " + joinPoint.getSignature().getName() + " method");
        Object result = joinPoint.proceed();
        System.out.println("After " + joinPoint.getSignature().getName() + " method");
        return result;
    }
    @Pointcut("execution(public * com.example.myapp.service.*.*(..))")
    public void serviceMethods() {}
}