精华内容
下载资源
问答
  • 学过很多面向XX编程,比如:面向过程编程,面向对象编程,面向接口编程,现在又是面向切面编程。但是不管如何,说来说去最终都是面向搜索引擎编程:面向百度编程,面向谷歌编程。今日学习内容安排:AOP的引入,它...

    今天是刘小爱自学Java的第123天。

    感谢你的观看,谢谢你。

    bedebb63cbf25acf9991d836c186fa14.png

    学过很多面向XX编程,比如:

    面向过程编程,面向对象编程,面向接口编程,现在又是面向切面编程。

    但是不管如何,说来说去最终都是面向搜索引擎编程:面向百度编程,面向谷歌编程。

    今日学习内容安排:

    • AOP的引入,它到底是干嘛的?
    • AOP面向切面编程的思想概述,以及其常见术语的解释说明。
    • 两种AOP底层实现机制,同时也是对动态代理的再一次回顾学习。

    本来是打算将AOP知识点糅合到一篇文章中说明的,但是内容实在是太多了,写了近三千字一半都还没有学到,看来还是得慢慢来了。

    一、AOP的引入

    在学它之前,我们先要搞清楚它是干嘛的?

    dao层的方法基本都是增删改查,现在需要将所有方法都增加打印日志的功能,怎么办?

    如果我们每个方法里面都实现打印日志的功能,那也太复杂了,所以选择封装:

    c86027e091d01f51d28ec1d02166bb42.png

    ①方法的封装

    我们将打印日志的功能封装到一个特有方法中,只需要在其它方法中调用该方法即可。

    但是这样就有一个很大的问题:

    dao层不只有userDao这个类,还有其它的类,也需要打印日志的功能,那怎么办?

    ②继承

    我们将打印日志的功能封装到一个类中,哪个类需要该方法就继承它即可,根据继承的原则:子类可以直接使用父类的方法。

    但是代码还是有问题,会出现代码的侵入。

    有没有方法可以不用修改类中方法的任何内容,就能实现方法的拓展?

    有,就是代理类的使用。

    注意:我举的这些例子都是伪代码,并不代表本身的业务逻辑,只是为了引出AOP的概念。

    4960960e9a44e1514144930ec2f11224.png

    ③代码的侵入

    我们想给方法增加功能,使用继承的话都需要在对应方法中调用一个打印日志的方法。

    对方法本身修改了,有代码侵入,这是不符合OCP原则的,即对扩展开放,对修改关闭:你增强我的功能可以,但你不可以修改我

    ④使用代理

    在被代理类方法的基础上,拓展了一个打印日志的方法,本身的方法并没有发生任何变化。

    当然这里也是伪代码,并没有使用到动态代理,文章后面有更详细的一步步说明。

    我们以继承->代理的这种代码变化过程,引出AOP面向切面编程的概念。

    二、AOP概述及相关术语

    AOP全称Aspect Oriented Programing,翻译为面向切面编程,它是一种编程思想。

    我们都知道Java是一门面向对象编程的,即OOP全称Object Oriented Programming。

    AOP是OOP的延续,采取横向抽取机制,取代了传统纵向继承体系重复性代码的编写。

    简单的理解就是,它的作用和继承很像,但是它比继承要更强,用一句来说明AOP就是:

    基于原有目标对象,创建代理对象,在不修改原对象代码情况下,通过代理对象调用增强功能的代码,从而对原有方法进行增强 。

    关于AOP编程相关术语

    这些术语太生涩难懂了,每一个概念涉及到的知识面还很广,想要完全弄懂太难了。

    这里用一个例子来做说明,当然说明并不是很准确,但是对于新手来说方便理解记忆。

    9c84bc359101e05495564fc7adc08e04.png

    ①目标对象Target

    也就是需要被增强的对象。

    ②织入Weaving

    根据目标对象来创建代理对象的整个过程。

    ③代理对象Proxy

    即根据目标对象生成的代理对象。

    ④连接点JoinPoint

    所谓连接点是指那些被拦截到的点。

    就可以理解成对象中的方法,因为在Spring中,只支持方法类型的连接点。

    ⑤切入点PointCut

    所谓切入点就是连接点的一部分,即需要被拦截的连接点就是切入点。

    就可以理解成对象中需要增强的方法。

    ⑥通知Advice

    也就是增强的方法,例子中就是记录日志。

    通知分为前置通知、后置通知、异常通知、最终通知、环绕通知,这些后续会讲述。

    ⑦切面Aspect

    是通知和切入点的结合,通知和切入点共同定义了关于切面的全部内容。它的功能、在何时和何地完成其功能?说白了也就是:

    如何将增强方法添加到对应的方法中?

    此外还有一个术语叫:引介Introduction

    在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或属性,这个实际开发中基本涉及不到。

    AOP是基于动态代理的,基于两种动态代理机制:JDK动态代理和CGLIB动态代理。

    三、JDK动态代理实现AOP

    当然JDK动态代理很少使用,但是还是都写下,就当是对动态代理知识点的一个回顾。

    创建工厂类,该类可以获取代理类对象:

    309e7a256715a144e00f2996ad3e35e8.png

    ①获取代理对象方法

    通过代理工厂的该方法就可以获取一个代理对象,为了通用性将返回值设定为Object。

    ②实例化代理类对象

    Proxy类的静态方法newProxyInstance(),根据方法名也能知道它是干嘛的,基本上动态代理的核心就是这个方法,参数有三个:

    • 目标对象的类加载器。
    • 目标对象实现的接口有哪些。
    • 调用处理器。

    当然,其代码编写有更优的方式,在Cglib动态代理中会说明,此处就使用最原始的方式。

    ③调用处理器

    InvocationHandler是一个接口,使用匿名内部类的方式获取其对象,其有一个方法叫invoke,该方法也有三个参数。

    如果方法名是我们需要增强的方法,那么我们给它增加一个功能,也就是④。

    如果不是,那么调用自己就好了,也就是method.invoke(target,args)。

    代码写完,做个测试

    ae527b18eff338ce61c9570a922ab5f5.png

    ⑤功能测试

    因为在动态代理中我们只选择对queryAll方法增强,所以用代理对象调用queryAll方法时会额外输出“记录日志”。

    而update方法不增强,就只会执行本身的功能,也就是“更新数据”。

    当然Jdk动态代理有一个局限,就是必须要有接口才行,所以就引出了CGLIB的使用。

    四、CGLIB动态代理

    CGLIB(Code Generation Library)是一个强大的,高性能的开源项目。

    其作用最直接的解释就是:不需要接口也可以实现动态代理。

    18d56fc6741d4777e87f50043172af41.png

    ①获取代理对象生成器

    Enhancer,增强器的意思,也就是通过它来实现方法的增强。

    ②设置目标对象的Class对象

    该参数是目标对象的Class对象,不是类加载器,和Jdk动态代理有一定的区别。

    ③设置回调函数

    Jdk动态代理中的三个参数:类加载器、接口以及调用处理器,Cglib中不需要接口,该参数就相当于jdk动态代理中的调用处理器。

    setCallback方法的参数需要该接口的实现类对象,我们可以直接使用匿名内部类的方式作为参数,就和调用处理器一样。

    但是在本类中实现这个接口,不就有了一个现成的实现类么?而this表示谁调用我就是谁,本类或者本类的子类都行。

    这里进一步优化代码的编写,上述Jdk动态代理中也可以这样优化。

    ④intercept方法

    这是MethodInterceptor接口中的一个方法,intercept,翻译就是拦截的意思。

    其参数和Jdk中的调用处理器基本一样。

    ⑤生成代理对象

    enhancer调用create()生成代理对象。

    代码写完,做个测试

    1e41e6c3ba6f459bcd45e628ec20850a.png

    ⑥方法测试

    通过运行结果我们可以发现:和Jdk动态代理能达到一样增强选定方法的效果。

    注意:目标对象CustomerServicePlus并没有实现接口,如果使用Jdk动态代理是不行的,得使用Cglib动态代理才可以。

    最后

    谢谢你的观看。

    如果可以的话,麻烦帮忙点个赞,谢谢你。

    展开全文
  • 精品学习资料获取通道,参见文末什么是AOPAOP(Aspect-OrientedProgramming,面向方面编程),它利用一种称为“横”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为...

    欢迎关注头条号:java小马哥

    周一至周日早九点半!下午三点半!精品技术文章准时送上!!!

    精品学习资料获取通道,参见文末

    4651550f6583a122a6016b3b89830b88.png

    什么是AOP

    AOP(Aspect-OrientedProgramming,面向方面编程),它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即方面。所谓“方面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。

    AOP使用场景

    AOP用来封装横切关注点,具体可以在下面的场景中使用:

    Authentication 权限

    Caching 缓存

    Context passing 内容传递

    Error handling 错误处理

    Lazy loading 懒加载

    Debugging 调试

    logging, tracing, profiling and monitoring 记录跟踪 优化 校准

    Performance optimization 性能优化

    Persistence 持久化

    Resource pooling 资源池

    Synchronization 同步

    Transactions 事务

    Spring AOP底层技术

    Spring提供了两种方式来生成代理对象: JDKProxy和Cglib,具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口,则使用JDK动态代理技术,否则使用Cglib来生成代理。

    动态代理利用反射的原理,给对象动态的生产代理对象,在执行的方法前后来执行相关内容:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 动态代理类

    *

    * @author yanbin

    *

    */

    public class DynamicProxy implements InvocationHandler {

    /** 需要代理的目标类 */

    private Object target;

    /**

    * 写法固定,aop专用:绑定委托对象并返回一个代理类

    *

    * @param delegate

    * @return

    */

    public Object bind(Object target) {

    this.target = target;

    return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

    }

    /**

    * @param Object

    * target:指被代理的对象。

    * @param Method

    * method:要调用的方法

    * @param Object

    * [] args:方法调用时所需要的参数

    */

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    Object result = null;

    // 切面之前执行

    System.out.println("切面之前执行");

    // 执行业务

    result = method.invoke(target, args);

    // 切面之后执行

    System.out.println("切面之后执行");

    return result;

    }

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    CGLIB是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强。采用的是继承的方式

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 使用cglib动态代理

    *

    * @author yanbin

    *

    */

    public class CglibProxy implements MethodInterceptor {

    private Object target;

    /**

    * 创建代理对象

    *

    * @param target

    * @return

    */

    public Object getInstance(Object target) {

    this.target = target;

    Enhancer enhancer = new Enhancer();

    enhancer.setSuperclass(this.target.getClass());

    // 回调方法

    enhancer.setCallback(this);

    // 创建代理对象

    return enhancer.create();

    }

    @Override

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

    Object result = null;

    System.out.println("事物开始");

    result = methodProxy.invokeSuper(proxy, args);

    System.out.println("事物结束");

    return result;

    }

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    AOP相关概念

    方面(Aspect):一个关注点的模块化,这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的 Advisor或拦截器实现。

    连接点(Joinpoint): 程序执行过程中明确的点,如方法的调用或特定的异常被抛出。

    通知(Advice): 在特定的连接点,AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型,维护一个“围绕”连接点的拦截器链。Spring中定义了四个advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice

    切入点(Pointcut): 指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点:例如,使用正则表达式。 Spring定义了Pointcut接口,用来组合MethodMatcher和ClassFilter,可以通过名字很清楚的理解, MethodMatcher是用来检查目标类的方法是否可以被应用此通知,而ClassFilter是用来检查Pointcut是否应该应用到目标类上

    引入(Introduction): 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如,你可以使用一个引入使任何对象实现 IsModified接口,来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知,通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口

    目标对象(Target Object): 包含连接点的对象。也被称作被通知或被代理对象。POJO

    AOP代理(AOP Proxy): AOP框架创建的对象,包含通知。 在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。

    织入(Weaving): 组装方面来创建一个被通知对象。这可以在编译时完成(例如使用AspectJ编译器),也可以在运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。

    几种实现方式

    1、基于代理的AOP

    2、纯简单java对象切面

    3、@Aspect注解形式的

    4、注入形式的Aspcet切面

    面先写一下几个基本的类。

    接口类:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 定义一个接口

    * @author 陈丽娜

    * @version 2015年5月31日上午9:16:50

    */

    public interface Sleepable {

    /**

    * 睡觉方法

    * @author 陈丽娜

    * @version 2015年5月31日上午9:17:14

    */

    void sleep();

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    实现类:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 陈丽娜 本人实现睡觉接口

    * @author 陈丽娜

    * @version 2015年5月31日下午4:51:43

    */

    public class ChenLliNa implements Sleepable {

    @Override

    public void sleep() {

    // TODO Auto-generated method stub

    System.out.println("乖,该睡觉了!");

    }

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    增强类:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 定义一个睡眠的增强 同时实现前置 和后置

    * @author 陈丽娜

    * @version 2015年5月31日上午9:24:43

    */

    public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {

    @Override

    public void afterReturning(Object returnValue, Method method,Object[] args, Object target) throws Throwable {

    System.out.println("睡觉前要敷面膜");

    }

    @Override

    public void before(Method method, Object[] args, Object target)throws Throwable {

    System.out.println("睡觉后要做美梦");

    }

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    1、基于代理的AOP

    24ac4e152b7183aab2cba3fd6368cb58.gif
    24ac4e152b7183aab2cba3fd6368cb58.gif

    如配置文件中:

    pattern属性指定了正则表达式,他匹配所有的sleep方法

    使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是为了使切点和增强结合起来形成一个完整的切面

    最后配置完后通过org.springframework.aop.framework.ProxyFactoryBean产生一个最终的代理对象。

    2、纯简单java对象切面

    纯简单java对象切面这话怎么说呢,在我看来就是相对于第一种配置,不需要使用代理,,而是通过spring的内部机制去自动扫描,这时候我们的配置文件就该如下修改:

    24ac4e152b7183aab2cba3fd6368cb58.gif
    24ac4e152b7183aab2cba3fd6368cb58.gif

    是不是相对于第一种简单了许多,不用再去配置代理了。

    3、@Aspect注解形式

    根据我们的经验也知道,注解的形式相对于配置文件是简单一些的,这时候需要在已有的方法或类上家注解:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 通过注解的方式 添加增强

    * @author 陈丽娜

    * @version 2015年5月31日上午10:26:13

    */

    @Aspect

    @Component

    public class SleepHelper03 {

    /*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/

    @Pointcut("execution(* *.sleep(..))")

    public void sleeppoint(){}

    @Before("sleeppoint()")

    public void beforeSleep(){

    System.out.println("睡觉前要敷面膜");

    }

    @AfterReturning("sleeppoint()")

    public void afterSleep(){

    System.out.println("睡觉后要做美梦");

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    配置文件中只需写:

    24ac4e152b7183aab2cba3fd6368cb58.gif
    24ac4e152b7183aab2cba3fd6368cb58.gif

    4、注入形式的Aspcet切面

    个人感觉这个是最简单的也是最常用的,也是最灵活的。配置文件如下:

    24ac4e152b7183aab2cba3fd6368cb58.gif
    24ac4e152b7183aab2cba3fd6368cb58.gif

    配置文件中提到的SleepHelper02类如下:

    24ac4e152b7183aab2cba3fd6368cb58.gif

    /**

    * 通过注解的方式 添加增强

    * @author 陈丽娜

    * @version 2015年5月31日上午10:26:13

    */

    public class SleepHelper02 {

    public void beforeSleep(){

    System.out.println("睡觉前要敷面膜");

    }

    public void afterSleep(){

    System.out.println("睡觉后要做美梦");

    }

    }

    24ac4e152b7183aab2cba3fd6368cb58.gif

    封面图源网络,侵权删除)

    私信头条号,发送:“资料”,获取更多“秘制” 精品学习资料

    如有收获,请帮忙转发,您的鼓励是作者最大的动力,谢谢!

    一大波微服务、分布式、高并发、高可用的原创系列文章正在路上,

    欢迎关注头条号:java小马哥

    周一至周日早九点半!下午三点半!精品技术文章准时送上!!!

    十余年BAT架构经验倾囊相授

    展开全文
  • 1. 何为AOPAOP:面向切面编程,相对于OOP面向对象编程。Spring AOP存在的目的是为了解耦,AOP可以让一组类共享相同的行为,在OOP中只能通过继承类喝实现接口,来使代码的耦合度增强,且类继承只能为单继承,阻碍更多...

    每天分享一点Java知识,码字不易,喜欢的可以关注一波,共同学习。20191127

    本篇将详细讲解SpringAOP的概念以及如何实现。

    1. 何为AOP

    AOP:面向切面编程,相对于OOP面向对象编程。

    Spring AOP存在的目的是为了解耦,AOP可以让一组类共享相同的行为,在OOP中只能通过继承类喝实现接口,来使代码的耦合度增强,且类继承只能为单继承,阻碍更多行为添加到一组类上,AOP弥补了OOP的不足。

    2. AspectJ的注解式切面编程

    a. 使用注解@Aspect声明是一个切面;

    b. 使用注解@After、@Before、@Around等定义建言(advice),可直接将拦截规则(切点)作为参数;

    c. 其中@After、@Before、@Around参数的拦截规则为切点(PointCut),为了使切点复用,可使用@PointCut专门定义拦截规则,然后在@After、@Before、@Around的参数中调用;

    d. 其中符合条件的每一个被拦截处为连接点(JoinPoint)。

    3. 下面将演示基于注解拦截和基于方法规则拦截两种方式,演示一种模拟记录操作的日志系统的实现。其中注解式拦截能够很好的控制要拦截的粒度和获得更丰富的信息,Spring本身在事务处理(@Transcational)和数据缓存(@Cacheable等)上面都使用此种形式的拦截。

    4. 代码示例:

    a. 添加依赖

    i. 添加Spring Aop支持以及AspectJ依赖

    acd7384c8697f98a737c5df898ec7cc1.png

    spring-aop依赖

    0456b417c2d4b21845bfb6c4d8ce9799.png

    AspectJ依赖

    b. 编写拦截规则的实现

    277f48b2be7a2962749cbe264c82d3c4.png

    拦截规则注解

    解释:注解本身是没有功能的,就和xml一样。注解和xml都是一种元数据,元数据即解释数据的数据,这就是所谓配置。注解的功能来自用这个注解的地方。

    c. 编写使用注解的被拦截类

    07fc223ca6c9d9122b2dec916fa16c7e.png

    注解拦截类

    d. 编写使用方法规则被拦截类

    120400dd9f9def16da046d826a99b671.png

    e. 编写切面

    92ca1aced20525b403468b923dae0c8c.png

    切面类

    解释:

    i. 通过@Aspect注解声明一个切面;

    ii. 通过@Component让此切面成为Spring容器管理的Bean;

    iii. 通过@PointCut注解声明切入点;

    iv. 通过@After注解声明一个建言,并使用@PointCut定义的切点;

    v. 通过反射可以获得注解上的属性,然后做日志记录相关的操作,下面的相同;

    vi. 通过@Before注解声明一个建言,此建言直接使用拦截规则作为参数。

    f. 配置类

    d21cb1ea42ffb0ae573fcfd138f243b0.png

    注解配置

    解释:使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持。

    g. 运行

    8bd1e297d2e0381222da4b67e02109e3.png

    运行测试

    h. 结果

    d275e31d6acde9dc591f4c6ffef90603.png

    运行结果

    5. 至此,便完成了Spring Aop的实现,相信大家对aop的理解也会更深一步。


    想获取完整面试题及答案的同学请点赞、关注并转发。私信楼主:“Java面试题”获取完整资料,更有超全spring、jvm、linux、docker等电子书相送。更有整理的200多页的面试重点知识点,非常全面,需要的私信。

    展开全文
  • 最近在搞一个统一给接口参数加解密的工具吧,之前的做法是通过filter进行参数解密,然后再分发到对象的controller接口,业务接口处理后,通过AOP切面去加密参数返回给第三方,后面想了另外一种方式,直接通过AOP的...

    最近在搞一个统一给接口参数加解密的工具吧,之前的做法是通过filter进行参数解密,然后再分发到对象的controller接口,业务接口处理后,通过AOP切面去加密参数返回给第三方,后面想了另外一种方式,直接通过AOP的环绕增强给参数做加解密;切面这块就不展开讲了,主要处理的是标题的内容,下面进入正题:

    @getter
    @setter
    class BaseParam<T>{
    	//密文
    	private String ciphertext;
    	//接口的真实对象
    	private T realData;
    	
    }
    

    比如上述对象,前端或者其他人调用的时候传密文进来,然后我这边通过切面,先把参数解密,然后set进真实的对象里面;如下面的controller登录接口

    public String login(@RequestBody BaseParam<LoginVO> body){
    	//业务处理
    }
    

    这样,登录接口就把泛型确定了;然后通过切面如何获取登录接口的泛型的真实类型呢?
    很简单,我先卖个关子,先讲一下我的心路历程:

    切面
    用户
    filter
    controller

    如上图所示,我一开始的思路是这样的:(我不知道controller上一层是谁调过来的啊,哪位大能看到希望可以指正一下)我在切面里面处理filter给过来的参数,去判断filter给过来的参数的realData的真实泛型是什么类型,途中还使用了ResolvableType去获取类型,但是获取的结果不是Object就是“?”,或者是"T",根本无法知道真实类型
    后面我想了下,思路倒过来了,应该想去到目标的接口去获取方法上面的泛型的真实类型,再通过解密后set回realData里面;果然方向错了就容易进死胡同
    在切面里是如何获取真实泛型呢;
    看代码:

    public Object doAround(ProceedingJoinPoint joinPoint){
    
     MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
     Method method = methodSignature.getMethod();
     Type[] types = method.getGenericParameterTypes();
      //获取方法里面第一个参数里面的第一个泛型
     Type argument = ((ParameterizedType) 
     
     types[0]).getActualTypeArguments()[0];
     Object[] args = joinPoint.getArgs();
     BaseParam arg;
    if( args[o] instanceof BaseParam){
    	//这里一般是遍历,我为了方便写就直接拿第一个了
    	arg =  (BaseParam )args[0];
    }
     //解密业务 todo
     String realDataJsonStr = decrypt(arg .realData);
     //使用的是ObjectMapper
     Object value = json.readValue(realDataJsonStr , json.constructType(argument));
     arg.setRealData(value);
     args[0] = arg;
     //执行方法
     Object proceed = joinPoint.proceed(args);
     //参数加密 todo
     
     return obj; 
    }
    

    代码纯手敲,中间可能会有些语法或者不知名错误,可以参考思路;
    参数加解密一般所有接口都会有,所以用个切面或者拦截器做统一处理对于走业务接口的话,就会很方便了;

    展开全文
  • 在使用aop切面时,如何获取参数信息 获取jdk自带对象 @Around(value = "@annotation(***)") public Object process(ProceedingJoinPoint joinPoint) throws Throwable { Method method = this.getMethod...
  • springboot aspect 切面获取请求数据

    千次阅读 2019-07-14 10:19:48
    基于项目是springboot所以想到用切面aspect来实现这个功能。前提: 前端post提交数据的方式是:application/json,而且由于接口中一般都是用@RequestBoy +对象 的方式来接收参数的。 所以像一般的方式: ...
  • Spring的AOP功能就是面向切面编程.我们从Spring容器取出的值,就是已经被重新包装过代理对象概念 通知: 要切入的内容 切点: 要切入的地方 切面织入: 将切面织入类的方法中,切面=通知+切点 通知的类在该类中声明各自...
  • 在某些时候,我们可能需要反射技术来获取其方法来使用它,但是方法名,方法的参数可能全都不知道 传入的参数具体是什么我们也不知道 例如,在使用切面的时候, ProceedingJoinPoint种getArgs也只是一个Object数组...
  • 通过自定注解将sql语句拼接好后不知道如何获取springboot中的数据库连接对象执行sql语句,请大神指教(不想通过最原始的获取配置文件的连接参数、获得连接。。。这种方式,是想用mybatis中的连接) ``` package ...
  • JoinPoint 对象 封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装该方法信息的对象 常用api ; 方法名 功能 Signature getSignature(); 获取封装了署名信息的对象,在该...
  • SpringAop切面获取方法的返回值

    万次阅读 2019-11-07 17:50:55
    当接口抛出异常的时候封装成response对象,但是如果不同接口要返回的response不同,需要在执行前获取到接口返回值的类型 如果要取到方法的返回值,需要先获取到method的对象 遵守这个思路 可以看到 around方法的参数...
  • 1,Signature getSignature();... 获取传入目标方法的参数对象 3,Object getTarget(); 获取被代理的对象 4,Object getThis(); 获取代理对象 5,final Object proceed = joinPoint.proceed(); 获取里面的数据 ...
  • 获取方法的某个参数的属性的值(返回值类型不确定,需要的参数对象中位置不确定) #2)举例         需求:记录操作日志,保存用户删除订单、购买物品等操作  &...
  • AOP面向切面编程

    2021-05-07 23:51:47
    文章目录AOP面向切面编程场景模拟改进利用动态代理实现spring实现了AOP功能,底层就是动态代理专有名词AOP实现JoinPoint获取目标参数的信息与返回值 AOP面向切面编程 AOP(Aspect Oriented Programming):面向切面...
  • AOP 是基于spring , 通过aspect注解实现:可以获取访问的类 方法 以及参数值....定义切面: package com.test.aop; import java.util.Date; import java.util.List; import org.aspectj.lang....
  • 过滤器 -> 通过集成Filter实现. 缺点如下 1.1 无法获取请求要访问的类与...切面 -> 基于spring , 通过aspect注解实现 3.1 可以获取访问的类 方法 以及参数值. 但是无法获取http原始的请求与相应的对象 执行顺序
  • 有一些鉴权问题的处理,每次都要根据当前登陆用户来获取权限对应的数据库字段,每次都要写一堆代码,感觉封装的话每次的使用的参数也不太一致,于是想到用aop的形式进行处理,主要对切面方法的请求参数进行处理。...
  • springboot写AOP切面

    2018-08-12 22:11:11
    前言:  Aop的应用领域:用于日志记录,性能统计,安全控制,事物处理,异常处理等;  AOP的主要功能:将那些影响多个类并... JoinPoint joinPoin:可以用这个对象获取方法的一些参数;  @Pointcut:定义一些...
  • 文章目录一、IoC容器中保存的是组件的代理对象二、切入点表达式的写法三、通知方法的执行顺序四、JoinPoint获取目标方法的信息五、throwing、returning指定哪个参数用来接收异常、返回值六、Spring对通知方法的约束...
  • 环绕注解和普通注解参数 ...//调用本类内部切入点对应其它通知或其它切面或目标方法。 Method targetMethod=getTargetMethod(jp);//使用自定义方法获取目标方法对象 String targetMethodName= targetMethod.getDeclarin
  • ">比如,如果不是用AspectJ时,会有接口BeforeAdvice的接口方法before(Method method, Object[] args, Object obj)的方法入参给予访问目标对象方法和入参的途径,而如果采用@AspectJ定义的切面,如</span></p> ...
  • 目录一、pom导包二、日志注解类三、日志切面类四、自定义注解解析类五、日志记录方式方式一:参数为实体类对象方式二:参数为Map对象方式三:参数为基本数据类型总结 一、pom导包 导入注解相关包 <dependency>...
  • 2.获取动态代理类的对象 3.切入点表达式 <aop:config> <!-- 配置切入点 --> <aop:pointcut expression="切入点表达式" id="唯一标识"/> </aop:config> 切入点表达式的语法: ...
  • SpringAop中JoinPoint对象的使用方法

    千次阅读 2018-04-14 15:30:57
    JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象. 常用api: 方法名 功能 Signature getSignature(); 获取封装了署名信息的...
  • SpringAop中JoinPoint对象

    2018-03-21 10:27:00
    JoinPoint的用法 JoinPoint 对象 ...JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象.常用api: 方法名功能 Signatu...

空空如也

空空如也

1 2 3 4 5 6
收藏数 103
精华内容 41
关键字:

切面获取参数对象