spring-data-aop 进行切面编程日志记录

最新推荐文章于 2024-06-14 09:58:39 发布
最新推荐文章于 2024-06-14 09:58:39 发布
阅读量169 收藏
点赞数
文章标签： runtime 操作系统 json
原文链接：http://www.cnblogs.com/java-hardly-road/p/11170751.html
版权

spring-data-aop

用途主要是记录日志和做切面增强
项目demo： https://github.com/woyaochengweidaniu/spring

项目启动直接访问接口即可在控制台看到效果--------------------

依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lcm</groupId>
    <artifactId>aop</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>aop</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.11</version>
        </dependency>
        <!-- 解析 UserAgent 信息 -->
        <dependency>
            <groupId>eu.bitwalker</groupId>
            <artifactId>UserAgentUtils</artifactId>
            <version>1.21</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
切点可以用注解 也可以用表达式
1创建注解
package com.lcm.aop.annon;


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


/**
 * 创建注解
 * RetentionPolicy.RUNTIME   生命周期   运行时
 *ElementType.METHOD   标记在什么地方    方法上
 *
 * @author lcm
 * @date created in 2019 7 11
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OpLog {

    String operation() default "";

    String target() default "";
}
创建切面
package com.lcm.aop.aspectj;


import com.lcm.aop.annon.OpLog;
import lombok.extern.slf4j.Slf4j;
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.stereotype.Component;

/**
 * <p>进行注解式切面编程</p>
 * @author lcm
 * @date created in 2019 7 11
 *
 */
@Slf4j
@Aspect
@Component
public class OpreationLog {


    /**
     *<p>只需要在方法上添加注解即可</p>
     */
    @Pointcut("@annotation(com.lcm.aop.annon.OpLog)")
    public void operation(){}


    /**
     * <p>带有log的注解并且切入点是operation  返回的是Object</p>
     * @param joinPoint
     * @param opLog
     * @param o
     */
    @AfterReturning(value = "operation()&&@annotation(opLog)",returning = "o")
    public void AfterReturning(JoinPoint joinPoint, OpLog opLog, Object o){

        log.info("操作类型：{}",opLog.operation());
        log.info("操作目标：{}",opLog.target());
        log.info("返回对象：{}",o);

        Object[] args = joinPoint.getArgs();
        for (Object object:args) {

            log.info("参数：{}",object);

        }


    }
}
创建service
package com.lcm.aop.service;

import com.lcm.aop.annon.OpLog;
import org.springframework.stereotype.Service;

/**
 * @author lcm
 */
@Service
public class TestSerivce {


    @OpLog(operation = "删除",target = "订单")
    public Object delete(String id){
        System.out.println(id);
        return "success";

    }

}
创建controller
package com.lcm.aop.api;

import com.lcm.aop.service.TestSerivce;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author lcm
 */
@RestController
public class ApiController {

    @Autowired
    private TestSerivce serivce;

    /**
     * 测试方法
     *
     * @param id 测试参数
     */
    @GetMapping("/test2")
    public Object test2(String  id) {
        Object delete = serivce.delete(id);
        return delete;
    }

}
2使用表达式进行切点切入
package com.lcm.aop.aspectj;

import cn.hutool.json.JSONUtil;
import eu.bitwalker.useragentutils.UserAgent;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.Objects;

/**
 * @author lcm
 * <P>记录切面日志</P>
 * @date created in 2019 7 11
 * @author lcm
 * @deprecated 切面不仅可以做日志 还可以做方法增强
 *
 */
@Aspect
@Component
@Slf4j
public class AopLog {
    private static final String START_TIME = "request-start";

    /**
     * 切入点
     */
    @Pointcut("execution(public * com.lcm.aop.controller.*Controller.*(..))")
    public void log() {

    }

    /**
     * 前置操作
     *
     * @param point 切入点
     */
    @Before("log()")
    public void beforeLog(JoinPoint point) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();

        log.info("【请求 URL】：{}", request.getRequestURL());
        log.info("【请求 IP】：{}", request.getRemoteAddr());
        log.info("【请求类名】：{}，【请求方法名】：{}", point.getSignature().getDeclaringTypeName(), point.getSignature().getName());

        Map<String, String[]> parameterMap = request.getParameterMap();
        log.info("【请求参数】：{}，", JSONUtil.toJsonStr(parameterMap));
        Long start = System.currentTimeMillis();
        request.setAttribute(START_TIME, start);
    }

    /**
     * 环绕操作
     *
     * @param point 切入点
     * @return 原方法返回值
     * @throws Throwable 异常信息
     */
    @Around("log()")
    public Object aroundLog(ProceedingJoinPoint point) throws Throwable {
        Object result = point.proceed();
        log.info("【返回值】：{}", JSONUtil.toJsonStr(result));
        return result;
    }

    /**
     * 后置操作
     */
    @AfterReturning("log()")
    public void afterReturning() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();

        Long start = (Long) request.getAttribute(START_TIME);
        Long end = System.currentTimeMillis();
        log.info("【请求耗时】：{}毫秒", end - start);

        String header = request.getHeader("User-Agent");
        UserAgent userAgent = UserAgent.parseUserAgentString(header);
        log.info("【浏览器类型】：{}，【操作系统】：{}，【原始User-Agent】：{}", userAgent.getBrowser().toString(), userAgent.getOperatingSystem().toString(), header);
    }
}
创建controller
package com.lcm.aop.controller;

import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.StrUtil;
import com.lcm.aop.service.TestSerivce;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * 测试 Controller
 * </p>
 *
 * @package: com.xkcoding.log.aop.controller
 * @description: 测试 Controller
 * @author: yangkai.shen
 * @date: Created in 2018/10/1 10:10 PM
 * @copyright: Copyright (c) 2018
 * @version: V1.0
 * @modified: yangkai.shen
 */
@RestController
public class TestController {
    @Autowired
    private TestSerivce serivce;

    /**
     * 测试方法
     *
     * @param who 测试参数
     * @return {@link Dict}
     */
    @GetMapping("/test1")
    public Dict test1(String who) {
        return Dict.create().set("who", StrUtil.isBlank(who) ? "me" : who);
    }



}
启动项目然后访问端口 如果端口号指定了，就按照指定的端口号访问

浏览器输入：http://localhost:8081/test1
浏览器输入：http://localhost:8081/test2

转载于:https://www.cnblogs.com/java-hardly-road/p/11170751.html

aijueyong5298
关注
Spring-----AOP面向切面编程---实现不同框架下的登录日志
莫绝岚的小屋
07-14 629
Spring ----AOP面向切面编程的详细操作及登录日志的实现
springAOP面向切面编程之日志记录功能
一只喜欢学习的猪仔
12-22 1万+
关于AOP： 这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。面向切面编程（AOP是Aspect Oriented Program的首字母缩写） ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代
AOP切面编程日志记录
淡定，情绪
06-08 396
要放假过端午呢在剩下的点时间里写点东西 之前有一篇文档 http://pengbaowei0311.iteye.com/blog/2302882 （comet4j 消息推送） 我接着从哪里说吧   comet4j 做为消息推送 但必须的有数据来源，数据来源我们直接在当前的接口服务类方法里封装吗？接口太多了，会累死人的，而且接口类还是别人写的，我不想改别人的东西，要不出现问题还以为是我...
Spring AOP面向切面编程之日志记录
小东升职记
12-20 1059
实际项目中我们往往需要将一些重要的操作，以日志的形式进行保存，当机器宕机的时候，可以通过查找日志，定位出错位置，方便恢复。 1：首先导入spring支持的AOP架包 2：编写将要进行切面工作的类 /** * */ package com.zhiyou100.aspect; import java.util.Arrays; import org.aspectj.lang.JoinP...
使用AOP切面实现日志记录功能
心态的博客
10-26 4920
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
AOP切面加自定义注解，实现日志记录
最新发布
Q95470的博客
06-14 1337
【代码】AOP切面加自定义注解，实现日志记录。
spring boot 使用AOP+自定义注解+反射实现操作日志记录修改前数据和修改后对比数据，并保存至日志表
yuechuzhixing的博客
09-08 3605
*** 写入日志表时，字段对应的中文注释*/@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到@Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法@Documented //说明该注解将被包含在javadoc中/*** 汉字全称* @return*/
spring aop切面拦截指定类和方法实现流程日志跟踪
10-26
为了解决这一问题，可以利用Spring框架中的AOP（Aspect Oriented Programming，面向切面编程）技术来实现。 #### 二、Spring AOP 概述 Spring AOP 是Spring框架提供的一种实现AOP的方法。通过AOP，开发者可以在不...
Springboot基于Aop面向切面编程生成数据日志基础讲解
weixin_49297205的博客
12-04 587
Springboot基于Aop面向切面编程生成数据库日志记录
spring-5.3.9-dist.zip（spring-framework-5.3.9）
01-07
Spring框架由多个模块组成，如Core Container（核心容器）、Data Access/Integration（数据访问/集成）、Web、AOP（面向切面编程）、Test等。每个模块都有相应的jar包，例如`spring-context.jar`提供了上下文支持，`...
06- AOP（实现案例：记录日志操作）
m0_63757196的博客
05-29 2427
面向切面编程、面向方面编程)，其实就是面向特定方法编程：代码无侵入、减少重复代码、提高开发效率、维护方便以下代码是从tlias案例中复制过来的1. 案例部分功能运行较慢,定位执行耗时较长的业务方法,此时需要统计每一个业务方 法的执行耗时完成！: JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息):Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法): PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用。
Spring项目AOP通知获取数据
时代各有不同，青春一脉相承。
10-29 838
AOP通知获取数据。获取切入点方法的参数，所有的通知类型都可以获取参数，JoinPoint：适用于前置、后置、返回后、抛出异常后通知，ProceedingJoinPoint：适用于环绕通知；获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究；获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究。
spring AOP切面及日志记录实现
q495673918的博客
02-22 3386
1.什么是AOP切面 AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一。 在项目中经常会有些系统性的需求，例如权限校验，日志记录，统计等，这时我们就可以通过AOP切面去实现。 有多少业务代码就需要写多少重复校验和日志记录，这显然是不合理的，我们可以把这些重复操作抽离出来，写成公共的方法。 这样，代码冗余解决了，但是每个地方都要手动去调用还是很麻烦，有没有更好的方式呢？这就要用到我们的AOP（面向切面编程），AOP将权限校验，
使用AOP(面向切面编程)记录日志
shz_123的博客
03-03 3104
使用AOP(面向切面编程)记录日志
【SpringBoot】SpingBoot整合AOP
热门推荐
lmb55的专栏
09-07 15万+
说起spring，我们知道其最核心的两个功能就是AOP（面向切面）和IOC（控制反转），这边文章来总结一下SpringBoot如何整合使用AOP。 一、示例应用场景：对所有的web请求做切面来记录日志。 1、pom中引入SpringBoot的web模块和使用AOP相关的依赖： 其中： cglib包是用来动态代理用的,基于类的代理； aspectjrt和aspectjweave...
SpringBoot——自动配置依赖[spring-boot-starter-XXX]
hackerHL的博客
10-18 1万+
SpringBoot之所以流行的原因，主要就是因为自动配置依赖——【约定优先于配置】，提供日常企业应用的各种场景。有非常多的“开箱即用”的依赖模块，也是SpringBoot快速高效的原因。默认支持和提供了【80+的自动配置依赖模块】SpringBoot提供的自动配置依赖模块都以spring-boot-starter-为命名前缀，并且这些依赖都在org.springframework.boot下。
SpringBoot实现切面AOP简单记录日志
qq_39853669的博客
05-07 2037
简述：该方式用于简单记录操作日志等，其实有很多第三方的日志框架，每一个公司也有自己的日志跟踪记录等，需要的童鞋可以自己搜寻。以下代码在灵活用于项目中，可自行决定。 下面可单独建立一个springboot单体应用，供其它module调用，作为依赖的方式；也可直接嵌入到其它moudle中，但这样有点繁琐，建议作为单独功能提取出来，类似于公共工具。 1、日志实体 @Entity @Getter @Setter @Table(name = "sys_log") @NoArgsConstructor public c
Spring的切面编程（AOP）概念与使用AOP实现日志记录
her_he的博客
08-02 486
使用Spring AOP实现日志记录功能
使用AOP切面实现日志记录
imVainiycos的博客
09-29 1486
本文参考EL-ADMIN 后台管理系统，学习相关AOP(Aspect-Oriented Programming:面向切面编程)，并实现使用AOP进行日志管理。特别感谢该项目的源代码作者：elunez 文章目录一、准备阶段二、编码阶段三、使用阶段 一、准备阶段 SpringBoot中需要先引入aop依赖 <!-- Mybatis-plus --> <dependency> <groupId>com.baomidou</groupId> &lt.
spring aop切面编程
09-01
Spring AOP切面编程是一种通过配置的方式，实现在Spring开发中的AOP功能。切面由切点和增强组成，切点用于定义在哪些连接点上应用增强，而增强指的是在连接点上要执行的逻辑操作。Spring的AOP强大之处在于不需要通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值