SpringBoot Aop 详解和多种使用场景解析

<!--aop 切面-->

        <dependency>

            <groupid>org.springframework.boot</groupid>

            <artifactid>spring-boot-starter-aop</artifactid>

        </dependency>

@restcontroller

public class aopcontroller {

     @requestmapping ( "/hello" )

     public string sayhello(){

         system.out.println( "hello" );

         return "hello" ;

     }

}

@aspect

@component

public class aopadvice {

     @pointcut ( "execution (* com.shangguan.aop.controller.*.*(..))" )

     public void test() {

     }

     @before ( "test()" )

     public void beforeadvice() {

         system.out.println( "beforeadvice..." );

     }

     @after ( "test()" )

     public void afteradvice() {

         system.out.println( "afteradvice..." );

     }

     @around ( "test()" )

     public void aroundadvice(proceedingjoinpoint proceedingjoinpoint) {

         system.out.println( "before" );

         try {

             proceedingjoinpoint.proceed();

         } catch (throwable t) {

             t.printstacktrace();

         }

         system.out.println( "after" );

     }

}

package cn.soboys.core;

import lombok.data;

/**

  * @author kenx

  * @version 1.0

  * @date 2021/6/18 18:48

  * 日志信息

  */

@data

public class logsubject {

     /**

      * 操作描述

      */

     private string description;

     /**

      * 操作用户

      */

     private string username;

     /**

      * 操作时间

      */

     private string starttime;

     /**

      * 消耗时间

      */

     private string spendtime;

     /**

      * url

      */

     private string url;

     /**

      * 请求类型

      */

     private string method;

     /**

      * ip地址

      */

     private string ip;

     /**

      * 请求参数

      */

     private object parameter;

     /**

      * 请求返回的结果

      */

     private object result;

     /**

      * 城市

      */

     private string city;

     /**

      * 请求设备信息

      */

     private string device;

}

package cn.soboys.core;

import org.aspectj.lang.proceedingjoinpoint;

import org.aspectj.lang.reflect.methodsignature;

import java.lang.reflect.method;

/**

  * @author kenx

  * @version 1.0

  * @date 2021/6/18 14:52

  * 切面

  */

public class baseaspectsupport {

     public method resolvemethod(proceedingjoinpoint point) {

         methodsignature signature = (methodsignature)point.getsignature();

         class <?> targetclass = point.gettarget().getclass();

         method method = getdeclaredmethod(targetclass, signature.getname(),

                 signature.getmethod().getparametertypes());

         if (method == null ) {

             throw new illegalstateexception( "无法解析目标方法: " + signature.getmethod().getname());

         }

         return method;

     }

     private method getdeclaredmethod( class <?> clazz, string name, class <?>... parametertypes) {

         try {

             return clazz.getdeclaredmethod(name, parametertypes);

         } catch (nosuchmethodexception e) {

             class <?> superclass = clazz.getsuperclass();

             if (superclass != null ) {

                 return getdeclaredmethod(superclass, name, parametertypes);

             }

         }

         return null ;

     }

}

package cn.soboys.core;

import cn.hutool.core.date.dateutil;

import cn.hutool.core.date.timeinterval;

import cn.hutool.json.jsonutil;

import cn.soboys.core.utils.httpcontextutil;

import io.swagger.annotations.apioperation;

import lombok.extern.slf4j.slf4j;

import org.aspectj.lang.proceedingjoinpoint;

import org.aspectj.lang.annotation.afterthrowing;

import org.aspectj.lang.annotation.around;

import org.aspectj.lang.annotation.aspect;

import org.aspectj.lang.annotation.pointcut;

import org.springframework.stereotype测试数据ponent;

import org.springframework.web.bind.annotation.requestbody;

import org.springframework.web.bind.annotation.requestparam;

import javax.servlet.http.httpservletrequest;

import java.lang.reflect.method;

import java.lang.reflect.parameter;

import java.util.arraylist;

import java.util.hashmap;

import java.util.list;

import java.util.map;

/**

  * @author kenx

  * @version 1.0

  * @date 2021/6/18 15:22

  * 全局日志记录器

  */

@slf4j

@aspect

@component

public class globallogaspect extends baseaspectsupport {

     /**

      * 定义切面pointcut

      */

     @pointcut ( "execution(public * cn.soboys.mallapi.controller.*.*(..))" )

     public void log() {

     }

     /**

      * 环绕通知

      *

      * @param joinpoint

      * @return

      */

     @around ( "log()" )

     public object doaround(proceedingjoinpoint joinpoint) throws throwable {

         logsubject logsubject = new logsubject();

         //记录时间定时器

         timeinterval timer = dateutil.timer( true );

         //执行结果

         object result = joinpoint.proceed();

         logsubject.setresult(result);

         //执行消耗时间

         string endtime = timer.intervalpretty();

         logsubject.setspendtime(endtime);

         //执行参数

         method method = resolvemethod(joinpoint);

         logsubject.setparameter(getparameter(method, joinpoint.getargs()));

         httpservletrequest request = httpcontextutil.getrequest();

         // 接口请求时间

         logsubject.setstarttime(dateutil.now());

         //请求链接

         logsubject.seturl(request.getrequesturl().tostring());

         //请求方法get,post等

         logsubject.setmethod(request.getmethod());

         //请求设备信息

         logsubject.setdevice(httpcontextutil.getdevice());

         //请求地址

         logsubject.setip(httpcontextutil.getipaddr());

         //接口描述

         if (method.isannotationpresent(apioperation. class )) {

             apioperation apioperation = method.getannotation(apioperation. class );

             logsubject.setdescription(apioperation.value());

         }

         string a = jsonutil.tojsonprettystr(logsubject);

         log.info(a);

         return result;

     }

     /**

      * 根据方法和传入的参数获取请求参数

      */

     private object getparameter(method method, object[] args) {

         list<object> arglist = new arraylist<>();

         parameter[] parameters = method.getparameters();

         map<string, object> map = new hashmap<>();

         for ( int i = 0 ; i < parameters.length; i++) {

             //将requestbody注解修饰的参数作为请求参数

             requestbody requestbody = parameters[i].getannotation(requestbody. class );

             //将requestparam注解修饰的参数作为请求参数

             requestparam requestparam = parameters[i].getannotation(requestparam. class );

             string key = parameters[i].getname();

             if (requestbody != null ) {

                 arglist.add(args[i]);

             } else if (requestparam != null ) {

                 map.put(key, args[i]);

             } else {

                 map.put(key, args[i]);

             }

         }

         if (map.size() > 0 ) {

             arglist.add(map);

         }

         if (arglist.size() == 0 ) {

             return null ;

         } else if (arglist.size() == 1 ) {

             return arglist.get( 0 );

         } else {

             return arglist;

         }

     }

}