Spring基础学习（二）课程笔记 Spring-AOP-优快云博客

本文详细介绍了面向切面编程(AOP)的基本概念和技术原理，包括动态代理机制、AOP术语解释及如何使用Spring框架实现AOP操作。通过具体示例展示了基于注解和XML配置的AOP实现方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

理解：不通过修改源代码方式添加新的功能

1、底层原理：动态代理

a.有接口情况,使用JDK动态代

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了...");
        return a+b;
    }
    @Override
    public String update(String id) {
        System.out.println("update方法执行了...");
        return id;
    }
}

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(
            JDKProxy.class.getClassLoader(),
            interfaces,
            new UserDaoproxy(userDao)
        );
        int result = dao.add(1,2);
        System.out.println("result:"+result);
    }
}
class UserDaoproxy implements InvocationHandler{
    //1.谁的代理对象,把谁传递过来
    //有参数构造传递
    private Object obj;
    public UserDaoproxy(Object obj){
            this.obj = obj;
    }
    //增强的逻辑写到invoke函数中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法之前执行..."+method.getName()+":传递函数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(obj,args);
        //方法之后
        System.out.println("方法之后执行..."+obj);
        return res;
    }
}

方法之前执行...add:传递函数...[1, 2]
add方法执行了...
方法之后执行...com.atguigu.spring5.UserDaoImpl@5387f9e0
result:3

b.没有接口情况,使用CGLIB动态代理

2、AOP术语

连接点：类里面那些方法可以被增强,这些方法称为连接点

切入点：实际被真正增强的方法,称为切入点

通知(增强)：实际增强的逻辑部分称为通知(增强)

前置通知：@Before 后置通知：@AfterReturning 环绕通知：@Around 异常通知：@AfterThrowing 最终通知：@after

切面：把通知应用到切入点过程

3、AOP操作

a.准备工作：Spring框架一般都是基于AspectJ实现AOP操作

b.导入依赖：

c.切入点表达式:

(1)知道对哪个类拿个方法进行加强

(2)语法结构：execution(权限修饰符类全路径)

(3)举例对com.atguigu.dao.BOOkDao类里面的add进行加强

execution(* com.atguigu.dao.BookDao.add(..))

对com.atguigu.dao.BOOkDao类里面的所有方法进行加强

execution(* com.atguigu.dao.BookDao.(..))

对com.atguigu.dao包里所有类里面的所有方法进行加强

execution( com.atguigu.dao..(..))

d.基于AspectJ实现AOP操作：

(1)基于注解方式实现(重点）：

@Component
public class User {
    public void add(){
        System.out.println("add...");
    }
}

//(1)在增强类里面,创建方法,让不同方法代表不同通知类型
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    @Before(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    //后置通知
    @AfterReturning(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("AfterReturning...");
    }
    //异常通知
    @AfterThrowing(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    //环绕通知
    @Around(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }
    //最终通知,类似finally
    @After(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
}

环绕之前...
before...
add...
after'...
after...
环绕之后...

公共切入点抽取-重用切入点定义

@Component
@Aspect //生成代理对象
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointDemo() {
    }
    
    //前置通知
    @Before(value="pointDemo()")
    public void before(){
        System.out.println("before...");
    }
    ...
}

有多个增强类对同一个方法进行增强,可以设置增强类优先级-@Order(NUMBER),数字越小,优先级越高

@Component
@Aspect
@Order(1)
public class PersonProxy {
    //前置通知
    @Before(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("Person Before...");
    }
}

@Component
@Aspect //生成代理对象
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointDemo() {
    }
    //前置通知
    @Before(value="pointDemo()")
    @Order(3)
    public void before(){
        System.out.println("before...");
    }
    ...
}

Person Before...
环绕之前...
before...
add...
after'...
after...
环绕之后...

(2)基于xml配置文件实现：

//被增强类
public class Book {
    public void buy() {
        System.out.println("buy...");
    }
}

//增强类
public class BookProxy {
    public void before() {
        System.out.println("before...");
    }
}

@Test
public void testAopXml(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean2.xml");
    Book book = context.getBean("book" , Book.class);
    book.buy();
}

<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
<!--配置aop增强-->
<aop:config>
  <!--切入点-->
  <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>

  <!--配置切面-让before方法在buy之前执行,这个过程就是配置切面-->
  <aop:aspect ref="bookProxy">
    <!--增强作用在具体的方法上-->
    <aop:before method="before" pointcut-ref="p"/>
  </aop:aspect>
</aop:config>