实现AOP的三种方式

实现AOP的三种方式

AOP是什么

Spring的一种横切技术,在开发时可能需要对原来的业务进行增强或者加日志,这个时候就可以使用AOP来对其进行操作。

java实现动态代理的两种方式

JDK动态代理

操作的实现了接口的实体类,利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。

CGLIB动态代理

利用ASM(开源的Java字节码编辑库,操作字节码)开源包,将代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

区别:JDK代理只能对实现接口的类生成代理;CGlib是针对类实现代理,对指定的类生成一个子类,并覆盖其中的方法,这种通过继承类的实现方式,不能代理final修饰的类。

实现AOP之前的准备工作

1、创建一个UserService接口

package com.cheng.service;

public interface UserService {
    void add();

    void delete();

    void update();

    void query();
}

2、创建UserServiceImpl类实现这个接口

package com.cheng.service;

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }
}

在Spring配置文件中注册Bean

<bean id="userService" class="com.cheng.service.UserServiceImpl"/>

创建好代理对象之后就可以进行之后的操作了。

方式一:spring自带API接口

1、编写两个类实现MethodBeforeAdvice和AfterReturningAdvice接口

before类:

public class Log implements MethodBeforeAdvice {

    //method: 要执行的目标对象的方法
    //args: 参数
    //target: 目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

after类:

public class AfterLog implements AfterReturningAdvice {

    //returnValue 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法,返回结果为:" + returnValue);
    }
}

2、在Spring配置文件中配置AOP切入点

<!--方式一:使用原生spring API接口-->
    <!--配置aop:需要导入aop约束-->
    <aop:config>
    <!--切入点 execution(要执行的位置)-->
    <aop:pointcut id="pointCut" expression="execution(* com.cheng.service.UserServiceImpl.*(..))"/>

    <!--执行环绕增加!-->
    <aop:advisor advice-ref="log" pointcut-ref="pointCut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointCut"/>

    </aop:config>

3、查看运行结果:
请添加图片描述

方式二:自定义类

使用自定义类的方式来对代理对象进行增强

1、首先需要DIY一个切入类实现需要切入的方法

public class diyPointCut {

    public void before() {
        System.out.println("========方法执行前========");
    }

    public void after() {
        System.out.println("========方法执行后========");
    }
}

2、在applicationContext.xml文件中进行配置

<!--方式二:自定义类-->
    <bean id="diy" class="com.cheng.diy.diyPointCut"/>

    <aop:config>
    <!--自定义切面 : ref 要引入的类-->
    <aop:aspect ref="diy">
    <!--切入点-->
    <aop:pointcut id="point" expression="execution(* com.cheng.service.UserServiceImpl.*(..))"/>
    <!--通知-->
    <aop:before method="before" pointcut-ref="point"/>
    <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
    </aop:config>

3、运行结果:

请添加图片描述

方式三:注解实现

使用注解相对而言就比较简单,只需要在Spring配置文件中开启注解支持 aop:aspectj-autoproxy/

并将对应切入类注册Bean就可以使用了

1、创建AnnotationPointCut类使用注解切入

@Aspect//标注这个类是切面
public class AnnotationPointCut {

    @Before("execution(* com.cheng.service.UserServiceImpl.*(..))")//切入位置
    public void before() {
        System.out.println("方法执行前");
    }

    @After("execution(* com.cheng.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("方法执行后");
    }

    //在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点
    @Around("execution(* com.cheng.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前:");

        Signature signature = joinPoint.getSignature();
        System.out.println("signature: " + signature);
        //执行方法
        Object proceed = joinPoint.proceed();

        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

可以看出如果需要使用注解进行切入:

​ 1、首先需要在类前注解@Aspect表明这是一个切面类

​ 2、可以使用注解@Before,@After,@Around并给定一个execution()参数表明切入点来对其需要的位置进行切入

2、注册Bean并打开注解支持

<!--方式三:注解实现-->
<bean id="annotationPointCut" class="com.cheng.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

3、运行结果:
请添加图片描述

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AOP(面向切面编程)是一种编程思想,用于在不修改原始代码的情况下,将横切关注点(如日志记录、安全性、事务管理等)从核心业务逻辑中分离出来。下面是AOP的两种实现方式和底层原理: 1. 静态代理:静态代理是通过手动编写代理类来实现AOP。在这种方式中,需要创建一个代理类,该代理类实现了与目标对象相同的接口,并且在方法执行前后进行横切逻辑的处理。在编译期间,将横切逻辑与核心业务逻辑进行织入,生成代理类的字节码文件。因此,客户端调用代理类的方法时,会自动执行横切逻辑。 2. 动态代理:动态代理是通过反射机制实现AOP。Java提供了两种动态代理方式:基于接口的动态代理(JDK动态代理)和基于类的动态代理(CGLIB动态代理)。 - JDK动态代理:在运行时,通过创建一个实现InvocationHandler接口的代理类,并使用Proxy类的静态方法newProxyInstance()来生成代理对象。当客户端调用代理对象的方法时,会触发InvocationHandler的invoke()方法,在invoke()方法中进行横切逻辑的处理。 - CGLIB动态代理:CGLIB是一个第三方库,通过生成目标类的子类来实现动态代理。在运行时,CGLIB通过继承目标类,并重写目标类的方法来实现横切逻辑的处理。 底层原理:AOP底层原理主要依赖于Java的反射机制。在运行时,AOP框架通过反射获取目标对象的信息,然后通过代理类或者字节码增强技术,在目标对象的方法执行前后插入横切逻辑。这种方式实现了横切关注点的分离,使得核心业务逻辑与横切逻辑可以独立开发和维护。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值