Spring实现AOP的三种方式

Posted 2021-07-09 javatiange

前置条件

①导入jar

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies> 

②配置文件开启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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans> 

③抽象接口

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

④实现类：

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

    @Override
    public void delete() {
        System.out.println("删除用户");
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

    @Override
    public void selete() {
        System.out.println("查询用户");
    }
} 

一、通过 Spring API 实现

①添加前置后置方法

public class AopBeforeConfigLog implements MethodBeforeAdvice {

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

public class AopAfterConfigLog implements AfterReturningAdvice {

    /**
     * method : 要执行的目标对象的方法
     * args : 被调用的方法的参数
     * result : 返回值
     * target : 被调用的目标对象
     */

    @Override
    public void afterReturning(Object result, Method method, Object[] args, Object target){
        System.out.println(target.getClass()+"===="+method.getName()+"被执行了"+"===返回值"+result);
    }
} 

②beans.xml

 <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"/>
    <bean id="afterLog" class="aoptest.AopAfterConfigLog"/>
    <bean id="beforeAop" class="aoptest.AopBeforeConfigLog"/>

    <aop:config>
        <!--切入点  expression:表达式匹配要执行的方法-->
        <aop:pointcut id="cut" expression="execution(* service.UserServiceImpl.*(..))"/>

        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="afterLog" pointcut-ref="cut"/>
        <aop:advisor advice-ref="beforeAop" pointcut-ref="cut"/>
    </aop:config> 

③测试类：

public class TestAop {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("ContextAplication.xml");
        UserService userService = (UserService) Context.getBean("userService");
        userService.add();
        userService.selete();
        userService.update();
        userService.delete();
    }
} 

④执行结果：

⑤总结：

• 切面：横切的点
• 通知：切面完成的工作，其实就是一个方法
• 目标：被通知的对象
• expression="execution(* service.UserServiceImpl.*(..))"
  • 这是一套固定的公式
  • *代表所有
  • 这句话的意思就是service.UserServiceImpl下的所有方法都被切面了！

如果你觉得自己学习效率低，缺乏正确的指导，可以加入资源丰富，学习氛围浓厚的技术圈一起学习交流吧！
[Java架构群]
群内有许多来自一线的技术大牛，也有在小厂或外包公司奋斗的码农，我们致力打造一个平等，高质量的JAVA交流圈子，不一定能短期就让每个人的技术突飞猛进，但从长远来说，眼光，格局，长远发展的方向才是最重要的。

二、自定义类来实现

①自定义被切入类

/*
* 自定义类
* */
public class MyDIYAopCut {
    public void before(){
        System.out.println("方法执行前前前前前前前前前前");
    }
    public void after(){
        System.out.println("方法执行后后后后后后后后后后");
    }
} 

②beans.xml

 <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"/>
    <bean id="Mydiycut" class="diyaop.MyDIYAopCut"/>

    <aop:config>
        <!--这里的ref指定被 切入 的类是哪一个-->
        <aop:aspect ref="Mydiycut">
            <!--切入点-->
            <aop:pointcut id="cut" expression="execution(* service.UserServiceImpl.*(..))"/>

            <!--切入点之前执行,这里的方法名即是我们自定义类中的方法名-->
            <aop:before method="before" pointcut-ref="cut"/>
            <!--切入点之后执行,这里的方法名即是我们自定义类中的方法名-->
            <aop:before method="after" pointcut-ref="cut"/>
        </aop:aspect>
    </aop:config> 

③测试类不变，执行结果：

④总结：

• 测试类的方法即是xml中method的方法名

• 其他见xml中的注释！

三、使用注解实现

①自定义增强注解实现类

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

②xml

 <!--注册bean-->
    <bean id="userService" class="service.UserServiceImpl"/>
    <bean id="myAnnotationAopCut" class="diyaop.MyAnnotationAopCut"/>
    <!--声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面-->
    <aop:aspectj-autoproxy proxy-target-class="false"/> 

③测试类一致，执行结果

④总结：

• proxy-target-class="false"
  • false 是以jdk实现动态代理
  • true 是以CGLib实现动态代理
  • 这玩意我们一般使用默认机制，了解，知道有这么个玩意即可！
• @Aspect：把当前类标识为一个切面供容器读取
• @Before：方法执行前
• @After：方法执行后
• @Around：环绕式执行
  • ProceedingJoinPoint：环绕通知=前置+目标方法执行+后置通知。proceed方法就是用于启动目标方法执行的
  • 就是必须得使用proceed(),相当于中间点，这样程序才能知道哪个是before哪个是after！

---

最后

以下是Java面试1—到5年以上开发必问到的面试问点，也都是一线互联网公司Java面试必备技能，下面是参照阿里年薪50W所需具备的技能图，大家可以参考下！

同时针对这12个技能，我在这整理了一份Java架构进阶面试专题PDF文档（含450题解析，包括Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发，设计模式，MySQL等知识点解析，内容丰富，图文结合！）

这份专题文档是免费分享的，有需要的朋友可以看向下面来获取！！

需要完整版文档的小伙伴，可以一键三连，下方获取免费领取方式！