SpringAop的认识 (三) 之日志开发 (下)

PeterMrWang

已于 2022-03-31 19:24:55 修改

245

分类专栏： spring 文章标签： java spring

于 2022-03-30 22:45:38 首次发布

本文链接：https://blog.csdn.net/PeterMrWang/article/details/123859425

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

07、AOP的重要性

aop底层是jdk动态代理和cglib代理结合实现。
它可以解决上面所有的问题。
aop它会自动把springioc中的增强对象全部自动转换成代理对象。

08、Aop的底层的实现机制

jdk动态实现
cglib代理实现

不论是用那种实现：它的目标都是一致的把springioc的对象转化代理对象。

这是一个正常springioc的对象
在这里插入图片描述

09、Springioc对象转化代理对象？

为什么用做日志处理，你日志拦截处理和核心点是什么？

查看当前类的执行时长
根据时长可以判断当前是那个方法耗时，可以根据这个耗时的方法针对的性排查和优化。

01、定义日志注解

package com.kuangstudy.aop;

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

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface SysLog {

    String value() default "";
}

为什么要定义一个注解：

它就相当于一个小红旗，那个方法需要被AOP拦截就写上注解，红旗就出现在方法上。
因为springaop的切点表达式做了注解的条件处理，可以控制加了注解的方法菜会进行到通知（增强逻辑的位置）
不用注解可以吗？当然可以，但是不灵活，看场景
- execution 表达式（事务控制）
- within
- target （针对性的）
- args （针对的处理）
- this
- annatation(注解)–细粒度

02、实体类

package com.kuangstudy.entity;

import com.baomidou.mybatisplus.annotation.*;

import lombok.Data;


import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;


/**
 * 系统日志
 */
@Data
@TableName("sys_log")
public class SysLogEntity implements Serializable {
    private static final long serialVersionUID = 1L;


    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户名
     */
    private String username;

    /**
     * 用户操作
     */
    private String operation;

    /**
     * 请求方法
     */
    private String method;

    /**
     * 请求参数
     */
    private String params;

    /**
     * 执行时长(毫秒)
     */
    private Long time;

    /**
     * IP地址
     */
    private String ip;

    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
}

03、定义mapper

package com.kuangstudy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import com.kuangstudy.entity.SysLogEntity;
import org.apache.ibatis.annotations.Mapper;

/**
 * 系统日志
 */
@Mapper
public interface SysLogMapper extends BaseMapper<SysLogEntity> {
	
}

04、定义service

package com.kuangstudy.service.SysLog;

import com.baomidou.mybatisplus.extension.service.IService;
import com.kuangstudy.entity.SysLogEntity;

import java.util.Map;

/**
 * 系统日志
 *
 * @author zhcw63@163.com
 */
public interface SysLogService extends IService<SysLogEntity> {

}

05、定义serviceImpl

package com.kuangstudy.service.SysLog;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.kuangstudy.entity.SysLogEntity;
import com.kuangstudy.mapper.SysLogMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;


@Service("sysLogService")
public class SysLogServiceImpl extends ServiceImpl<SysLogMapper, SysLogEntity> implements SysLogService {
    
}

06、定义切面

@Component
- 让springioc容器管理这个切面，变成一家人。
@Aspect
- 标记为切面
连接点
- 切点表达式
通知
- 前置Advice — @Before(切点或者切点表达式)
- 后置Advice — @After(切点或者切点表达式)
- 异常Adivce – @AfterThrowing(切点或者切点表达式)
- 环绕Advice ---- @Around(切点或者切点表达式)
- 后置返回Advice ----@AfterRetuning(切点或者切点表达式)

package com.kuangstudy.aop;

import com.google.gson.Gson;
import com.kuangstudy.config.userlocal.UserThreadLocal;
import com.kuangstudy.entity.SysLogEntity;
import com.kuangstudy.entity.User;
import com.kuangstudy.service.SysLog.SysLogService;
import com.kuangstudy.utils.HttpContextUtils;
import com.kuangstudy.utils.IPUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
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.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;

@Component
@Aspect
@Slf4j
public class LogAspect {

    @Autowired
    private SysLogService sysLogService;

    // 1: 定义切入点，切入点标注有注解@KsdLog的的所有函数，通过 @Pointcut 判断才可以进入到具体增强的通知
    @Pointcut("@annotation(com.kuangstudy.aop.SysLog)")
    public void logpointcut() {
    }

    @Around("logpointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;
        //保存日志
        saveSysLog(point, time);
        return result;
    }
    

    private void saveSysLog(ProceedingJoinPoint joinPoint, long time) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        SysLogEntity sysLog = new SysLogEntity();
        SysLog syslog = method.getAnnotation(SysLog.class);
        if(syslog != null){
            //注解上的描述
            sysLog.setOperation(syslog.value());
        }

        //请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        sysLog.setMethod(className + "." + methodName + "()");

        //请求的参数
        Object[] args = joinPoint.getArgs();
        try{
            String params = new Gson().toJson(args);
            sysLog.setParams(params);
        }catch (Exception e){

        }

        //获取request
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        //设置IP地址
        sysLog.setIp(IPUtils.getIpAddr(request));

        //用户名
        User user = UserThreadLocal.get();
        sysLog.setUsername(user.getNickname());

        sysLog.setTime(time);
        //保存系统日志
        sysLogService.save(sysLog);
    }
}

在需要拦截的方法上增加@KsdLog注解

package com.kuangstudy.first;

import com.kuangstudy.aop.KsdLog;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class OrderService {

    @Autowired
    private LogService logService;

    /**
     * 订单注册
     *
     * @param order
     */
    @KsdLog
    public void saveOrder(Order order) {
        log.info("订单注册....");

        // 记录日志
        Logs logs = new Logs();
        logs.setClassname("com.kuangstudy.service.OrderService");
        logs.setMethod("saveOrder");
        logs.setId(1);
        logs.setParams(order.toString());
        logs.setTime("100ms");
        logService.saveLog(logs);
    }

    /**
     * 修改订单
     *
     * @param order
     */
    @KsdLog
    public void updateOrder(Order order) {
        log.info("修改订单....");

        // 记录日志
        Logs logs = new Logs();
        logs.setClassname("com.kuangstudy.service.OrderService");
        logs.setMethod("updateOrder");
        logs.setId(1);
        logs.setParams(order.toString());
        logs.setTime("100ms");
        logService.saveLog(logs);
    }


    /**
     * 删除订单
     *
     * @param orderId
     */
    @KsdLog
    public void delOrder(Integer orderId) {
        log.info("删除订单....{}", orderId);

        // 记录日志
        Logs logs = new Logs();
        logs.setClassname("com.kuangstudy.service.OrderService");
        logs.setMethod("delOrder");
        logs.setId(1);
        logs.setParams(orderId.toString());
        logs.setTime("100ms");
        logService.saveLog(logs);
    }

}

运行测试代码如下：

这个时候我们很清晰的看orderService变成了代理对象

在这里插入图片描述

10、结论

在spring底层框架中，它是ioc做核心基础，ioc做的管理项目所有的bean对象。如果这些管理的bean中的任何一个方法只要和aop的切面有管理。就会把这些bean全部转换成代理对象。
因为只有代理对象执行方法，才可以进入到代理类（切面）中去做逻辑增强处理
而哪些如果没用加满足条件的方法，全部会自然抛弃和正常执行，而满足条件的就进入对应通知中进行逻辑增强。
springboot默认情况下代码类型是：cglib代理，而spring的框架默认代理：jdk动态代理。
- 因为jdk动态代理必须要接口。
- 但是在有些情况下，开发不需要接口，依然要能够支持代理，现如用jdk动态代理就无法上西安
- 为解决这种众口难调的情况，有些喜欢面向类变成，有人喜欢面向接口编程spring都做了兼容和支持。

PeterMrWang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringAop的认识 (三) 之日志开发 (下)

07、AOP的重要性aop底层是jdk动态代理和cglib代理结合实现。它可以解决上面所有的问题。aop它会自动把springioc中的增强对象全部自动转换成代理对象。08、Aop的底层的实现机制jdk动态实现cglib代理实现不论是用那种实现：它的目标都是一致的把springioc的对象转化代理对象。这是一个正常springioc的对象09、Springioc对象转化代理对象？为什么用做日志处理，你日志拦截处理和核心点是什么？查看当前类的执行时长根据时长可以判断当前是那
复制链接

扫一扫