万字长文！深入底层带你理解Spring之AOP，看完还不会真的算

作者: 程序员伟杰 | 来源:发表于2021-05-10 16:51 被阅读0次

什么是AOP

AOP (Aspect Oriented Programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

个人整理了一些资料，有需要的朋友可以直接点击领取。

AOP在Spring中的作用

提供声明式事务;允许用户自定义切面
横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面(ASPECT)︰横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice):切面必须要完成的工作。即，它是类中的一个方法。
目标(Target)︰被通知对象。
代理(Proxy)︰向目标对象应用通知之后创建的对象。
切入点(PointCut)︰切面通知执行的“地点"的定义。
连接点(JointPoint) :与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即Aop在不改变原有代码的情况下，去增加新的功能.

使用Spring实现AOP

需要的依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

方式一：使用原生的Spring API接口

UserService.java

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("【Debug】执行了add方法");
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("【Debug】执行了delete方法");
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("【Debug】执行了update方法");
        System.out.println("修改了一个用户");
    }

    public void query() {
        System.out.println("【Debug】执行了query方法");
        System.out.println("查询了一个用户");
    }
}

Log.java

public class Log implements MethodBeforeAdvice {
    /**
     *
     * @param method 要执行目标对象方法
     * @param args   参数
     * @param target 目标对象
     * @throws Throwable
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"类中的"+method.getName()+"方法执行了");
    }
}

applicationContext.xml

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="userService" class="com.test.service.impl.UserServiceImpl"/>
    <bean id="log" class="com.test.log.Log"/>
    <bean id="afterLog" class="com.test.log.AfterLog"/>
    <!--方式一：使用原生的Spring API接口-->
    <!--配置aop需要导入约束-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.test.service.impl.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

AfterLog.java
这个地方必须是写接口，因为代理的对象是接口；

public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(method.getName()+"方法执行了，值为"+returnValue);
    }
}

方式二：自定义来实现AOP

UserService.java

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("【Debug】执行了add方法");
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("【Debug】执行了delete方法");
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("【Debug】执行了update方法");
        System.out.println("修改了一个用户");
    }

    public void query() {
        System.out.println("【Debug】执行了query方法");
        System.out.println("查询了一个用户");
    }
}

DiyPointcut.java

public class DiyPointcut {
    public void before() {
        System.out.println("方法前执行！");
    }
    public void after() {
        System.out.println("方法后执行！");
    }
}

applicationContext.xml

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="diy" class="com.test.diy.DiyPointcut"/>
    <bean id="userService" class="com.test.service.impl.UserServiceImpl"/>
    <!--方式二：使用自定义实现AOP-->
    <aop:config>
        <aop:aspect ref="diy">
            <aop:pointcut id="diyPointcut" expression="execution(* com.test.service.impl.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="diyPointcut"/>
            <aop:after method="after" pointcut-ref="diyPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

AfterLog.java
这个地方必须是写接口，因为代理的对象是接口；

public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(method.getName()+"方法执行了，值为"+returnValue);
    }
}

注解实现AOP

UserService.java

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("【Debug】执行了add方法");
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("【Debug】执行了delete方法");
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("【Debug】执行了update方法");
        System.out.println("修改了一个用户");
    }

    public void query() {
        System.out.println("【Debug】执行了query方法");
        System.out.println("查询了一个用户");
    }
}

AnnotationPointcut.java

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.test.service.impl.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("方法前执行！");
    }
    @After("execution(* com.test.service.impl.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("方法后执行！");
    }
    @Around("execution(* com.test.service.impl.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println(jp.getSignature());
        Object proceed = jp.proceed();
        System.out.println(proceed);
        System.out.println("环绕后");
    }
}

applicationContext.xml

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--方式三：使用注解实现AOP-->
    <bean id="annotationPointcut" class="com.test.annotation.AnnotationPointcut"/>
    <!--开启aop注解支持, 动态代理：jdk(默认) proxy-target-class="false" ，cgib proxy-target-class="true"-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>
    <bean id="userService" class="com.test.service.impl.UserServiceImpl"/>
</beans>

说明：
开启aop注解支持

<aop:aspectj-autoproxy/>

动态代理：jdk(默认) proxy-target-class=“false” ，cgib proxy-target-class=“true”
测试：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("aplicationContext.xml");
        //动态代理的是接口，需要注意！
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

①Spring4.0
　　　　正常情况：环绕前置-------->@Before-------->目标方法执行-------->环绕返回-------->环绕最终-------->@After-------->@AfterReturning
　　　　异常情况：环绕前置-------->@Before-------->目标方法执行-------->环绕异常-------->环绕最终-------->@After-------->@AfterThrowing
②Spring5.28
　　　　正常情况：环绕前置-------->@Before-------->目标方法执行-------->@AfterReturning-------->@After-------->环绕返回-------->环绕最终
　　　　异常情况：环绕前置-------->@Before-------->目标方法执行-------->@AfterThrowing-------->@After-------->环绕异常-------->环绕最终

网友评论

java技术交流社区

本文标题：万字长文！深入底层带你理解Spring之AOP，看完还不会真的算

本文链接：https://www.haomeiwen.com/subject/ncmidltx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

万字长文！深入底层带你理解Spring之AOP，看完还不会真的算

什么是AOP

AOP在Spring中的作用

使用Spring实现AOP

方式一：使用原生的Spring API接口

UserService.java

UserServiceImpl.java

Log.java

applicationContext.xml

方式二：自定义来实现AOP

UserService.java

UserServiceImpl.java

DiyPointcut.java

applicationContext.xml

注解实现AOP

UserService.java

UserServiceImpl.java

AnnotationPointcut.java

applicationContext.xml

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java技术交流社区