spring基础03-AOP1

3 Aop

3.1 啥是Aop

3.1.1 解释一下喽

  • Aspect Oriented Programming 面向切面编程
  • 通过预编译方式与运行期间动态代理实现程序功能的统一维护
  • 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
  • 翻译成人话：

    • 不修改原有代码，就能增加新的功能（增强一个类的功能）

    • 经典例子:登录功能的实现，增加新的验证用户权限的功能

    • image

3.1.2 AOP底层原理

  • AOP底层使用动态代理
    • 有两种情况的动态代理

      • 有接口情况，使用JDK动态代理

        • image

      • 无接口情况，使用CGLIB动态代理

        • image

a. JDK动态代理：

  • 例子：一个接口，一个实现类实现俩方法，用Proxy做动态代理，增强这个类的功能（修改原有方法a+b的功能）

  • 使用Proxy类做动态代理

 static object newProxyInstance(ClassLoader ,Class<?>[]  interface,InvocationHandler h)
	-param
     	类加载器
     	增强方法所在的类实现的接口，注意：可以使多个接口[]
     	实现这个接口Invocationhandler, 创建代理对象，写增强的方法

  • 编写JDK动态代理代码

    • 接口：

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

    • 实现类

    • public class UserDaoImpl implements UserDao{
    public void update(String id){
        System.out.println(id);
    }
    public int add(int a ,int b){//增强这个方法的功能
        return a+b;
    }
}

    • 代理类

    • public class JDKProxy {
    public static void main(String[] args) {
        UserDaoImpl userDao=new UserDaoImpl();
        System.out.println("实现类对象:"+userDao.toString());
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
        //第三个参数也可以用匿名内部类
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int res = userDaoProxy.add(1, 3);
        System.out.println(res);
    }
}
class UserDaoProxy implements InvocationHandler{
    private Object object;//记录被代理的是谁
    public UserDaoProxy(Object o){
        this.object =o;
    }
    //这里写增强的逻辑结构
    //把被代理的对象传进来
        //方法1：通过有参构造传进来
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //add方法之前新增的执行：
        System.out.println(method.getName()+"方法执行之前...,传递的参数："+ Arrays.toString(args));
        //add方法执行
        Object res = method.invoke(object, args);
        //方法执行之后
        System.out.println("方法执行之后..."+object);
        return res;
    }
}

    • 结果：

    • 实现类对象:com.zhang.demo01.aop.UserDaoImpl@19dfb72a
add方法执行之前...,传递的参数：[1, 3]
add方法执行了
方法执行之后...com.zhang.demo01.aop.UserDaoImpl@19dfb72a
4

b. 小问题

  • 怎么实现多个类的增强 在做method.invoke之前通过getName方法判断传进来的method是哪个方法

3.2 相关术语

  • 连接点

    • 一个类中，可以被增强的方法就是连接点 (们)
    • (理论为是个方法好像都能被增强)

  • 切入点

    • 实际被增强的方法就就是切入点

  • 通知（增强）

    • 实际增强的部分称为通知（代码块？）
    • 通知有多种类型
      • 前置通知：原方法执行之前执行
      • 后置通知：原方法执行完毕后执行
      • 环绕通知：原方法执行前后都可以执行！
      • 异常通知:原方法出现异常时执行
      • 最终通知:原方法异不异常都执行

  • 切面

    • 把通知应用到切入点的过程就是切面

3.2 AOP操作（准备工作）

3.2.1 AspectJ

  • spring框架一般般都是基于AspectJ实现aop操作
  • aspectJ不是Spring的组成部分，独立AOP矿建，一般把AspectJ和Spring框架一起使用
  • AspectJ实现AOP操作由两种方式，一种xml，一种注解

3.2.2 引入AOP依赖

spring-boot-starter-aop

3.2.3切入点表达式

通过这个表达式式，知道对哪个类的那个方法增强

  • 语法结构：
    • execution ( [ 权限修饰符 ] [ 返回类型 ] [ 类全路径 ] . [ 方法名称 ] [ 参数列表 ] )
    • 例如：
    • 对com.zhang.dao.BookDao的add方法进行增强
      • execution( * com.zhang.dao.BookDao.add( .. ) )//权限修饰符可以不写，但是返回值必须写，*表示任意
      • // .. 表示参数列表？？？
    • 对所有方法都增强
      • execution( com.zhang.dao.BookDao.( 参数列表) )
    • 对com.zhang.dao里所有类的所有方法都增强
      • execution( com.zhang.dao.*.*( 参数列表) )//表示任意

3.3AOP操作（AspectJ注解）

3.3.1 增强代理类实现各种不同的通知

  1. 普通类

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

  2. 创建增强类

    public class USerProxy {
    //前置通知的注解，参数是切入点表达式
    //翻译过来就是告诉这个方法加强在那个类的哪个方法的哪里
    @Before(value = "execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    
    @After=(value="execution(* com.zhang.demo01.aopanno.User.add(..))")
    //异常通知
    @AfterThrowing=()
        
    @AfterReturning(value="execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void afterReturning(){}//add方法返回之后再执行
    
    @Around(value="execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        proceedingJoinPoint.proceed();//add方法执行
        System.out.println("环绕之后");
    }
}

  3. 进行通知的配置

  • 在spring配置文件，开启注解扫描

  • <?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.zhang.demo01.aopanno"></context:component-scan>
</beans>

  • 使用注解创建USer和UserProxy对象

  • @Component

  • 在增强类上面添加注解@Aspect

  • @Component
@Aspect //生成代理对象
public class USerProxy {

  • 在spring配置文件中开启生成代理对象

  • <!--开启Aspect生成代理对象
    说白了就是找到有Aspectj注解的类，生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  1. 配置不同的通知，见前面2

  2. 测试

    • @Test
public void test3(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean-aop.xml");
    User user = context.getBean("user", User.class);
    user.add();
}

3.3.2相同切入点抽取

@Component
@Aspect //生成代理对象
public class USerProxy {

    @Pointcut(value="execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void pointDemo(){
    }

    @Before(value = "pointDemo()")
    public void before(){
        System.out.println("before...");
    }
}

3.3.3多增强类设置优先级

  • 多个增强类对同一个方法进行增强，设置增强类的优先级

  • 方法：在增强类的上面添加注解@Order(数字类型)，数值越小，优先级越高，默认优先级最小

  • @Order的源码

  • @Retention(RetentionPolicy.RUNTIME)//声明周期：运行时
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})//注释范围
@Documented
public @interface Order {
   /**
    * The order value.
    * <p>Default is {@link Ordered#LOWEST_PRECEDENCE}.
    * @see Ordered#getOrder()
    */
   int value() default Ordered.LOWEST_PRECEDENCE;
}
int LOWEST_PRECEDENCE = Integer.MAX_VALUE;//默认优先级是最低的

  • 普通类：

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

  • 增强类1

  • @Component
@Aspect //生成代理对象
@Order(1)
public class USerProxy {

    @Pointcut(value = "execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void pointDemo() {
    }

    //    前置通知的注解，参数是切入点表达式
	//    翻译过来就是告诉这个方法加强在那个类的哪个方法的哪里
    @Before(value = "pointDemo()")
    public void before() {
        System.out.println("User before...");

    }
}

  • 增强类2

  • @Component
@Aspect
@Order(3)
public class PersonProxy {
    //
    @Before(value ="execution(* com.zhang.demo01.aopanno.User.add(..))")
    public void before() {
        System.out.println("Person Before...");
    }
}

  • 测试类

  • @Test
public void test3(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean-aop.xml");
    User user = context.getBean("user", User.class);
    user.add();
}

3.3.4 完全注解开发

和IOC一样，在使用注解的时候，也都先配置了一下文件

IOC：

<!--声明context命名空间-->
<context:component-scan base-package="com.zhang.demo01"></context:component-scan>

然后可以把这个xml配置文件变成一个配置类，详见2.4.4

所以AOP也行：

AOP的配置文件：

<!--声明context命名空间-->
<context:component-scan base-package="com.zhang.demo01.aopanno"></context:component-scan>
<!--开启Aspect生成代理对象
     说白了就是找到有Aspectj注解的类，生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

同样，AOP也能用一个配置代替

@Configuration//告诉Spring，这是一个配置类，用来替代xml配置文件
@ComponentScan(basePackages = {"com.zhang.demo01"})//同IOC完全注解开发，告诉配置的那个包
@EnableAspectJAutoProxy(proxyTargetClass = true)//替代aop:aspectj-autoproxy标签
public class SpringConfigAop {
}

3.4 AOP操作（AspectJ配置文件）（一般不用）

先考虑下都要配置啥

  • 得修改配置文件xml的头吧

    • 添加俩空间：aop，context

  • 得用IOC配置生成俩对象吧

    • 用bean标签生成俩对象，参数包括id，对象所在类

  • 得用AOP配置aspectJ吧

    • 首先使用<aop:config>标签，告诉xml这是个aop配置
      • aop配置里面得告诉切入点在哪里:<aop:point-cut> (针对普通类的配置)
        • 参数id就是个名，expression就是切入点表达式
      • 得告诉aop用的哪个代理类<aop:aspect> （针对增强类的配置）
        • 再告诉aop是哪个通知 <aop:before> 标签，其他标签略
          • 参数method指向增强的方法
          • 参数pointcut-ref告诉增强了谁(指向回第一个aop:point-cut配置里面的id)

翻译成人话：

​ aop需要俩配置，第一个配置是普通类的，这个配置啥也没干，就是为了方便增强类的配置能找到他，所以起了个id

第二个配置是代理类（增强类的）要告诉aop用了啥通知，增强方法是哪个 ，被增强的是谁（普通类的id）

  1. 创建两个类，普通类和增强类，创建方法

    • public class BookProxy {
    public void before(){//前置方法，名字随便起，注解或者配置指明了它是前置方法就行
        System.out.println("before------");
    }
}

    • public class Book {
    public void buy(){
        System.out.println("buy------");
    }
}

  2. 在spring配置文件中创建两个类的对象

    • <!--创建俩类的对象-->
    <bean id="book" class="com.zhang.demo01.aopxml.Book"></bean>
    <bean id="bookproxy" class="com.zhang.demo01.aopxml.BookProxy"></bean>

  3. 在spring配置文件中配置切入点

    • <!--配置aop增强-->
    <aop:config>
        <!--配置切入点
            id就是个名，随便起-->
        <aop:pointcut id="p" expression="execution(* com.zhang.demo01.aopxml.Book.buy(..))"/>
        <!--配置切面（把增强应用到方法的过程）
            ref指向增强类-->
        <aop:aspect ref="bookproxy">
            <!--确定是哪个通知
                method指向增强的方法
                pointcut-ref指向切入点-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>

    </aop:config>

  4. 测试类

    • @Test
public void test4(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean-aop-xml.xml");
    Book book = context.getBean("book", Book.class);
    book.buy();
}

posted @   荧惑微光  阅读(59)  评论(0)  编辑  收藏  举报
相关博文：
·  spring基础 - 总结回顾
·  spring基础02-IOC容器2-基于xml操作bean管理
·  Spring(三)——AOP
·  Spring（四）--AOP
·  spring学习笔记4
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手