AOP:Aspect Oriented Programming ⾯向切⾯编程。
AOP 的优点:
● 降低模块之间的耦合度。
● 使系统更容易扩展。
● 更好的代码复⽤。
● ⾮业务代码更加集中,不分散,便于统⼀管理。
● 业务代码更加简洁存粹,不参杂其他代码的影响。
AOP 是对⾯向对象编程的⼀个补充,在运⾏时,动态地将代码切⼊到类的指定⽅法、指定位置上的编程思想就是⾯向切⾯编程。将不同⽅法的同⼀个位置抽象成⼀个切⾯对象,对该切⾯对象进⾏编程就是AOP。
如何使⽤?
● 创建 Maven ⼯程,pom.xml 添加

<?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>

    <groupId>org.example</groupId>
    <artifactId>springaop</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>
</project>

● 创建⼀个计算器接⼝ Cal,定义4个⽅法。

package com.yin;

public interface Cal {
    public int add(int num1,int mun2);
    public int sub(int num1,int mun2);
    public int mul(int num1,int mun2);
    public int div(int num1,int mun2);

}

● 创建接⼝的实现类 Call。

package com.yin;

public class Call implements Cal {

    public int add(int num1, int mun2) {
        System.out.println("add⽅法的参数是["+num1+","+mun2+"]");
       int result =num1 + mun2;
        System.out.println("add⽅法的结果是"+result);
        return result;
    }

    public int sub(int num1, int mun2) {
        System.out.println("sub⽅法的参数是["+num1+","+mun2+"]");
        int result =num1 - mun2;
        System.out.println("sub⽅法的结果是"+result);
        return result;
    }

    public int mul(int num1, int mun2) {
        System.out.println("mul⽅法的参数是["+num1+","+mun2+"]");
        int result =num1 * mun2;
        System.out.println("mul⽅法的结果是"+result);
        return result;
    }

    public int div(int num1, int mun2) {
        System.out.println("div⽅法的参数是["+num1+","+mun2+"]");
        int result =num1 / mun2;
        System.out.println("div⽅法的结果是"+result);
        return result;
    }
}

上述代码中,⽇志信息和业务逻辑的耦合性很⾼,不利于系统的维护,使⽤ AOP 可以进⾏优化,如何来实现 AOP?使⽤动态代理的⽅式来实现。
给业务代码找⼀个代理,打印⽇志信息的⼯作交个代理来做,这样的话业务代码就只需要关注⾃身的业务即可。

package com.yin;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class daili implements InvocationHandler {
    private  Object object =null;
    public  Object bind (Object object){
        this.object =object;
        return
                Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);

    }
    public Object invoke(Object proxy, Method method, Object[] args) throws
            Throwable {
        System.out.println(method.getName()+"⽅法的参数是:"+
                Arrays.toString(args));
        Object result = method.invoke(this.object,args);
        System.out.println(method.getName()+"的结果是"+result);
        return result;
    }
}

以上是通过动态代理实现 AOP 的过程,⽐较复杂,不好理解,Spring 框架对 AOP 进⾏了封装,使⽤Spring 框架可以⽤⾯向对象的思想来实现 AOP。
Spring 框架中不需要创建 InvocationHandler,只需要创建⼀个切⾯对象,将所有的⾮业务代码在切⾯对象中完成即可,Spring 框架底层会⾃动根据切⾯类以及⽬标类⽣成⼀个代理对象。

package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Aspect
@Component
public class LoggerAspect {
@Before(value = "execution(public int com.southwind.utils.impl.CalImpl.*
(..))")
public void before(JoinPoint joinPoint){
//获取⽅法名
String name = joinPoint.getSignature().getName();
//获取参数
String args = Arrays.toString(joinPoint.getArgs());
System.out.println(name+"⽅法的参数是:"+ args);
}
@After(value = "execution(public int com.southwind.utils.impl.CalImpl.*
(..))")
public void after(JoinPoint joinPoint){
//获取⽅法名
String name = joinPoint.getSignature().getName();
System.out.println(name+"⽅法执⾏完毕");
}
@AfterReturning(value = "execution(public int
com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
public void afterReturning(JoinPoint joinPoint,Object result){
//获取⽅法名
String name = joinPoint.getSignature().getName();
System.out.println(name+"⽅法的结果是"+result);
} @AfterThrowing(value = "execution(public int
com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
public void afterThrowing(JoinPoint joinPoint,Exception exception){
//获取⽅法名
String name = joinPoint.getSignature().getName();
System.out.println(name+"⽅法抛出异常:"+exception);
}
}

LoggerAspect 类定义处添加的两个注解:
● @Aspect :表示该类是切⾯类。
● @Component :将该类的对象注⼊到 IoC 容器。
具体⽅法处添加的注解:
@Before :表示⽅法执⾏的具体位置和时机。
CalImpl 也需要添加 @Component ,交给 IoC 容器来管理。

package com.southwind.utils.impl;
import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
public int add(int num1, int num2) {
int result = num1+num2;
return result;
}
public int sub(int num1, int num2) {
int result = num1-num2;
return result;
}
public int mul(int num1, int num2) {
int result = num1*num2;
return result;
}
public int div(int num1, int num2) {
int result = num1/num2;
return result;
}
}

spring.xml 中配置 AOP。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
<!-- ⾃动扫描 -->
<context:component-scan base-package="com.southwind">
</context:component-scan>
<!-- 是Aspect注解⽣效,为⽬标类⾃动⽣成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

context:component-scan 将 com.southwind 包中的所有类进⾏扫描,如果该类同时添加了
@Component ,则将该类扫描到 IoC 容器中,即 IoC 管理它的对象。
● aop:aspectj-autoproxy 让 Spring 框架结合切⾯类和⽬标类⾃动⽣成动态代理对象。
● 切⾯:横切关注点被模块化的抽象对象。
● 通知:切⾯对象完成的⼯作。
● ⽬标:被通知的对象,即被横切的对象。
● 代理:切⾯、通知、⽬标混合之后的对象。
● 连接点:通知要插⼊业务代码的具体位置。
● 切点:AOP 通过切点定位到连接点。

最后修改:2021 年 05 月 10 日 09 : 08 PM
如果觉得我的文章对你有用,请随意赞赏