【Java之AOP】

最新推荐文章于 2024-05-31 10:46:10 发布

Bigcoding

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量234

点赞数 5

分类专栏： # Java核心技术精选文章标签： java 开发语言

本文链接：https://blog.csdn.net/z140359/article/details/136702406

版权

Java核心技术精选专栏收录该内容

33 篇文章 0 订阅

订阅专栏

AOP

面向切面编程 Aspect Oriented Programming

切面：切入点+通知

给容器中的组件进行增强，AOP其实做的事情就是将委托类组件替换为代理组件，取出的组件就是代理组件。AOP做的是更精细的增强，并不是所有的组件里的方法都做增强，而是做筛选，开发人员提供筛选条件。

切入点 → 筛选容器中的组件中要被增强的方法

通知 → 做什么样的增强

编程术语

Target：目标类、委托类、被代理类

Proxy：代理类

PointCut：切入点

Advice：通知

Aspect：切面

JoinPoint：连接点，增强过程中的点。通过JoinPoint可以拿到一些参数（委托类对象、代理类对象、方法、参数）

Weaver：织入

案例

案例1使用工厂方法注册代理

FactoryBean

@Component
public class ServiceFactoryBean implements FactoryBean<UserService> {
    @Qualifier("userServiceImpl") 
    @Autowired
    UserService userService; //维护一个成员变量，用于增强
    @Override
    public UserService getObject() throws Exception {
        Object proxy = Enhancer.create(UserServiceImpl.class, new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("使用FactoryBean的动态代理进行增强");
                method.invoke(userService, objects);
                return null;
            }
        });
        return (UserService) proxy;
    }

    @Override
    public Class<?> getObjectType() {
        return UserService.class;
    }
}

这里一定要注意，因为我们的动态代理也会实现委托类的接口，所以在取出委托类的组件时要按照类型+id来取值，因为此时实现了接口，那就相当于有了两个这个类型的组件

@Autowired
@Qualifier("serviceFactoryBean")
UserService userServiceProxy;

 @Test
 public void test3(){
     userServiceProxy.demo();
 }

SpringAOP

Spring提供了一个生成动态代理对象的ProxyFactoryBean

通过getObject方法来生成代理对象，那么需要指定委托类对象，也需要指定增强

通知要实现接口 → MethodInterceptor → invoke

@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation var1) throws Throwable;
}

实现接口在导包的时候，一定要注意导的是org.aopalliance下的包

@Component
public class UserServiceInter implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("AOP的动态代理");
        Object proceed = methodInvocation.proceed(); //执行委托类的方法
        System.out.println("AOP的动态代理");
        return proceed;
    }
}

通知需要做的事情类似于InvocationHandler

1.委托类方法的执行

2.增强

通过配置文件来注册AOP的对象，target表示的是委托类，interceptorNames表示的就是通知的组件名

<!--ProxyFactoryBean已经编译好了-->
<bean id="userServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!--委托类组件-->
    <property name="target" ref="userServiceImpl"/>
    <!--interceptor是什么，长什么样 → 通知-->
    <property name="interceptorNames" value="customInterceptor"/>
</bean>

这里在取出的时候也要注意动态代理会实现委托类的接口，就会多产生一个该类型的实例，就不能使用取出类型的方法取出。

只有是在容器中注册一个代理类才会出现这种情况，如果没有在容器中注册，就不会。

AspectJ

Pointcut

切入点表达式→匹配的方法→判断方法是否在增强范围内→筛选方法进行增强

execution

大的范围指定，指定满足特征的方法

表达式的规范：execution(修饰符返回值包名、类名、方法名(形参))

例如：public void com.cskaoyan.service.UserService.sayHello();

1.能否省略

2.能否通配

3.特殊的用法

修饰符

可以省略→直接省略不写就代表任意的修饰符

返回值

不能省略，但可以使用通配符*来表示返回值可以是任意值

如果是Pojo类，那就需要写一个全限定类名，这里面也可以用通配符

例如：com.cskaoyan.bean.User→com.caskaoyan.*.User

包名、类名、方法名

只能省略一部分：包名的第一级和方法名不能省略（头尾不能省略），中间的任意一部分都可以省略

使用…进行省略，这里可以先写出完整的，然后中间的部分删去不写即可，只要用了…就表示省略，如果有多级的，那么也只需要使用一次…

public void com.cskaoyan.service.UserServiceImpl.sayHello();

中间加黑的部分都可以省略

例如：

execution(void com…service.UserServiceImpl.sayHello())

execution( void com.cskaoyan…UserServiceImpl.sayHello()😉

execution( void com.cskaoyan…sayHello()😉

可以使用通配符*，任意位置都可以使用

execution(void *.cskaoyan…sayHello())
execution(void com.cskaoyan…say*())

形参

public void com.cskaoyan.service.UserServiceImpl.sayHello()

可以省略不写→表示无参方法

可以使用通配符

*表示任意类型的单个字符

…表示任意参数(类型任意，数量任意)

同样的，如果是pojo类作为形参，那么需要写全限定类名

增强service层的任意方法：

execution(* com.cskaoyan.service…*(…))

前面的第一个…表示的是省略中间的包，*表示的任意方法名，方法参数的…表示的是任意参数

使用

需要引入依赖：aspectjweaver

<!--aspectjweaver → groupid为org.aspectj-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

引入aop的schema约束

<aop:config>
    <aop:pointcut id="mypointcut" expression="execution(* com.cskaoyan.service..*(..))"/>
</aop:config>

@annotation

指定要增强的具体的方法，注解的形式

@annotation(自定义的注解的全限定类名)

首先需要自定义一个注解，自定义的注解写在容器中的组件的哪个方法上，哪个方法就被划入了增强的范围

@Target(ElementType.METHOD)  //注解可以出现在方法上
@Retention(RetentionPolicy.RUNTIME) //注解生效时间：runtime运行时
public @interface CountTime {
}

<aop:pointcut id="mypointcut2" expression="@annotation(com.cskaoyan.anno.CountTime)"/>

Advisor

Advisor:pointcut + advice (实现MethodInterceptor接口)

<aop:config>
    <aop:pointcut id="myPointcut" expression="execution(* com.fh.service.*(..))"/>
    <aop:pointcut id="myPointcut2" expression="@annotation(com.fh.anno.CountTime)"/>

    <aop:advisor advice-ref="countTimeAdvice" pointcut-ref="myPointcut2"/>
</aop:config>

@Component
public class CountTimeAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = methodInvocation.proceed();
        long end = System.currentTimeMillis();
        System.out.println(methodInvocation.getMethod().getName() + "执行时间：" + (end - start));
        return proceed;
    }
}

pointcut属性：切入点，可以直接写execution表达式，也可以用注解

advisor：advice-ref表示的是通知的全限定类名，pointcut-ref表示指定的切入点

进行增强后，取出的组件就是增强后的代理组件，动态织入将委托类替换为代理类；此外，也需要看代理的对象是否在容器中注册，只有注册了才会起冲突。AspectJ中的没有注册，采取的是动态织入的方式。

Aspect

Aspect = pointcut + advice（提供好一些包含时间属性的通知）

具体的增强还是需要自己来实现

时间属性：相对于委托类方法的执行时间，是一个相对时间，只需要关注相对委托类的时间就行，不需要关注通知之间的时间。

Before ：在委托类方法之前执行
Around：一部分在之前，一部分在之后，类似于InvocationHandler，会使用invoke来调用委托类的方法
After：在委托类方法执行之后执行，类似于finally，不管发生什么情况，对应的方法一定会执行
AfterThrowing：在抛出异常后执行，类似于catch
AfterRetruning：在委托方法执行之后执行，可以获得执行的return的结果，如果抛出异常则不会执行

1.如何将通知和方法结合

将方法写在切面类中，作为通知方法

2.切面组件

1.注册组件

2.标记切面组件

@Component
public class CustomAspect {

    //before通知方法,方法名任意
    public void mybefore() {
        System.out.println("Before通知：正道的光1.0");
    }

    //after通知方法,方法名任意
    public void myafter() {
        System.out.println("After通知：照在大地上1.0");
    }

    //around通知方法 → 类似于InvocationHandler的invoke、类似于MethodInterceptor的invoke
    //要包含委托类方法的执行和增强两部分
    //around方法的返回值作为代理对象的执行结果 → 返回值为Object类型
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around的前半部分");

        //委托类方法的执行 → ProceedingJoinPoint
        Object proceed = proceedingJoinPoint.proceed();//执行的是委托类的方法

        //增强
        System.out.println("around的后半部分");

        return proceed + " niupi";
    }

    //afterReturning可以获得委托类方法的执行结果，意味着能够接收到这个值 → 形参中以Object接收
    //形参名自己定义
    public void afterReturning(Object returnValue) {
        System.out.println("afterReturning通知：" + returnValue);
    }

    //afterThrowing通知 抛出异常的时候执行 → 可以获得你抛出的异常对象
    //使用Exception或Throwable来接收
    public void afterThrowing(Throwable e) {
        System.out.println("afterThrowing通知：" + e.getMessage());
    }

}

<aop:aspect ref="customAspect"/>

如何将通知和切入点结合

使用配置文件：

<aop:config>
    <aop:pointcut id="mypointcut" expression="execution(* com.cskaoyan.service..*(..))"/>
    <aop:pointcut id="mypointcut2" expression="@annotation(com.cskaoyan.anno.CountTime)"/>
    <aop:aspect ref="customAspect">
        <!--子标签-->
        <!--指定方法为什么通知方法、通知是啥切入点-->
        <!--pointcut属性：直接写切入点表达式-->
        <!--pointcut-ref属性：引用了切入点的id-->
        <aop:before method="mybefore" pointcut-ref="mypointcut"/>
        <aop:after method="myafter" pointcut-ref="mypointcut"/>
        <aop:around method="around" pointcut-ref="mypointcut"/>
        <!--returning属性：after-returning通知方法中哪一个Object类型的形参来接收委托类方法的执行结果-->
        <aop:after-returning method="afterReturning" pointcut-ref="mypointcut" returning="returnValue"/>
        <!--throwing属性：afterThrowing通知方法中哪一个Exception或Throwable类型的形参来接收委托类方法抛出的异常-->
        <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/>
    </aop:aspect>
</aop:config>

如果委托类方法抛出异常

Around通知的后半部分和AfterReturning通知执行不到

After通知是可以执行到的，它类似于finally

共有的属性：method、pointcut(-ref)

特有属性：afterReturning → returning、AfterThrowing → throwing ，让通知方法的形参能够接收到一些值

aop：pointcut的作用范围

aop：pointcut标签可以写在aop:aspect标签里，这时候就表示的是局部变量

<aop:config>
    <!--全局变量：整个aop:config标签里都可以使用-->
    <aop:pointcut id="mypointcut" expression="execution(* com.cskaoyan.service..*(..))"/>
    <aop:aspect ref="customAspect">
        <!--局部变量：只能在当前aop:aspect标签里使用-->
        <aop:pointcut id="mypointcut3" expression="execution(* com.cskaoyan.service..*(..))"/>
    </aop:aspect>
</aop:config>

JoinPoint连接点

通过连接点，可以获得增强过程中的一些值：委托类对象、代理对象、方法、

提供这些值可以让业务更加灵活

写在Before通知或者Around通知的形参中

public interface ProceedingJoinPoint extends JoinPoint {
    
    //意味着委托类方法的参数不做变化
    Object proceed() throws Throwable;
	//意味着委托类方法传入你的参数
    Object proceed(Object[] var1) throws Throwable;
}
在around通知中，可以直接使用ProceedingJoinPoint的实例来获得对应的值

before通知里的使用

//before通知方法,方法名任意
public void mybefore(JoinPoint joinPoint) {
    System.out.println("Before通知：正道的光1.0");
    Object proxy = joinPoint.getThis();   //proxy代理对象
    Object target = joinPoint.getTarget();//target委托类对象

    //拿到方法
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();  //Signature的name就是方法名

    //委托类方法执行的参数
    Object[] args = joinPoint.getArgs();

}

around通知里的使用

public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    //比如说，我们将传给委托类方法的参数拿到
    Object[] args = proceedingJoinPoint.getArgs();
    //如果执行的是sayHello5我们做一个个性化的处理
    if ("sayHello5".equals(proceedingJoinPoint.getSignature().getName())) {
        //个性化的处理
        //原来传入的参数是songge → 现在给改一下 改成songge and ligenli
        args[0] += " and ligenli";

    }


    System.out.println("around的前半部分");

    //委托类方法的执行 → ProceedingJoinPoint
    //Object proceed = proceedingJoinPoint.proceed();//执行的是委托类的方法的参数
    Object proceed = proceedingJoinPoint.proceed(args);//执行的是委托类的方法，参数被修改


    //增强
    System.out.println("around的后半部分");

    return proceed + " niupi";
}

通过around可以对参数进行修改，更加灵活了，返回值就是最终的方法执行的结果

注解使用aspectj

需要做的事

aop:pointcut标签配置了切入点以及对应的切入点表达式
指定组件为切面组件
指定切面组件中的方法为一个什么样的通知方法
将方法和切入点绑定起来

打开AspectJ的注解开关

<aop:aspectj-autoproxy/>

注册切面类

在组件上增加一个@Aspect注解，将当前组件标记为切面组件；注意@Component不能省

@Aspect
@Component
public class CustomAspect {
    
}

切入点配置

以方法的形式存在：体现出切入点的id和表达式

id：方法名作为切入点的id
表达式：@Pointcut的value属性

@Pointcut("execution(* com.cskaoyan.service..*(..))")
public void mypointcut() {//只需要这个方法的方法名
}

指定方法为什么通知方法

在切面类中的方法上增加上通知注解：@Before、@After、@Around、@AfterReturning、@AfterThrowing

将方法与切入点绑定

利用通知注解的value属性

直接写切入点表达式
引用切入点对应的方法

//@Before("execution(* com.cskaoyan.service..*(..))") //直接写切入点表达式
@Before("mypointcut()")  //引用方法名时要有一对括号
public void mybefore(JoinPoint joinPoint) {

}
//afterReturning可以获得委托类方法的执行结果，意味着能够接收到这个值 → 形参中以Object接收
//形参名自己定义
@AfterReturning(value = "mypointcut()",returning = "returnValue")
public void afterReturning(Object returnValue) {
    System.out.println("afterReturning通知：" + returnValue);
}

//afterThrowing通知 抛出异常的时候执行 → 可以获得你抛出的异常对象
//使用Exception或Throwable来接收
@AfterThrowing(value = "mypointcut()",throwing = "e")
public void afterThrowing(Throwable e) {
    System.out.println("afterThrowing通知：" + e.getMessage());
}

Bigcoding

关注

5
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【Java之AOP】

面向切面编程 Aspect Oriented Programming切面：切入点+通知给容器中的组件进行增强，AOP其实做的事情就是将委托类组件替换为代理组件，取出的组件就是代理组件。AOP做的是更精细的增强，并不是所有的组件里的方法都做增强，而是做筛选，开发人员提供筛选条件。
复制链接

扫一扫