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>
before...
buy...

> 尚硅谷课程Spring5的课堂笔记

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值