IDEASpring2：AOP的AspectJ、切入点抽取、纯注解使用

鱼雨羽

已于 2022-12-20 11:24:30 修改

阅读量573

点赞数 2

分类专栏： Spring 文章标签：代理模式 java 开发语言

于 2022-05-27 20:06:05 首次发布

本文链接：https://blog.csdn.net/qq_31897241/article/details/124992316

版权

Spring 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

AOP

面向切面编程
降低耦合
不修改源代码的方式添加新功能，仅添加对应模块。
原理：动态代理
（1）有两种情况的动态代理
1.1有接口interface的情况，要使用JDK中的动态代理
有接口的时候，创建接口实现类的代理对象，通过代理对象来增强方法。
1.2没有接口的情况，使用CGLIB中的动态代理。
创建当前类子类的代理对象
JDK动态代理
Proxy类的方法创建代理对象
调用newProxyInstance方法，方法三个参数：类加载器、类实现的接口可多个，实现接口写增强的部分。

编写JDK动态代理代码（原理）反射

（1）创建接口，定义方法

package com.Dao;

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

（2）创建接口实现类，实现方法

package com.Dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

（3）使用Proxy类创建接口代理对象

package com.Dao;

import java.lang.reflect.Array;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] aaa={UserDao.class};//第二个参数，即接口，为数组类型
        UserDaoImpl userDao=new UserDaoImpl();
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),aaa,new UserDaoProxy(userDao));
    }
}
//创建代理对象代码
class   UserDaoProxy implements InvocationHandler{
 //1.创建的谁的代理对象，就把谁传进来，下面使用有参构造的方法传进来。
    //有参构造方法，这里是吧代理对象userDaoimpl通过参数传进来
    //有参构造方法
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj=obj;
    };

        @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;
        }
    }

在这里插入图片描述

AOP术语

1.连接点
类中可以被增强的方法，这些方法被称为连接点
2.切入点
实际被增强的方法，叫切入带你
3.通知/增强
实际增强的部分叫通知，增加的部分叫增强
通知有多种类型：前置通知、后置通知、环绕通知、异常通知、最终通知、
4.切面
是一个动作、过程，即把增强加入到切入点的过程。

实现AOP操作

1.基于Spring框架的AspectJ实现AOP操作
（1）AspectJ是独立的。不用依赖于Spring
2.基于AspectJ实现AOP
（1）基于xml
（2）基于注解（实际使用）
3.在项目中引入AOP相关依赖
pom的maven链接
4.切入点表达式
（1）作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构：
Execution（[权限修饰符]，[返回类型],[类的全路径全类名],[方法名],(参数列表)）

举例1:对com.atquigu.dao.BookDao类里面的add进行增强
//*代表任意的修饰符public private都行
//（..）表示方法中的参数
//add表示被增强的方法。
execution(* com.atauigu.dao.BookDao.add(..))

举例2:对com.atquigu.dao.BookDao类里面的所有方法进行增强
//*代表任意的修饰符public private都行
//（..）表示方法中的参数
//*表示所有方法。
execution(* com.atauigu.dao.BookDao.*(..))

举例3:对com.atquigu.dao包里的所有类和方法进行增强
//*代表任意的修饰符public private都行
//（..）表示方法中的参数
//*表示所有方法。
execution(* com.atauigu.dao.*.*(..))

Spring中一般通过AspectJ实现AOP操作

1.AspectJ不是Spring的组成，是一个独立的AOP框架。
2.基于AspectJ实现AOP
（1）xml方式（2）注解方式
3.在项目工程中引入AOP依赖
4.切入点表达式
（1）切入点表达式的作用：知道对哪个类哪个方法进行增强
（2）语法结构：
execution（[权限修饰符][返回类型][类的全类名][类的方法名称][参数列表]）

举例1
对 com.atguigu.dao,BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
举例 2: 对 com.atguigu.dao,BookDao 类里面的所有的方法进行增强
execution(*com.atquigu.dao.BookDao.* (..)
举例 3: 对 com.atguigu.dao,包里面所有类，类里面所有方法进行增强
execution(*com.atquigu.dao. * .* (..)

AOP操作（AspectJ注解方式）

1.创建被增强类，自己随便定义即可

package com.AOPanno;

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

    }
}

2.创建增强类，编写增强的逻辑

package com.AOPanno;
//被增强类
public class User {
    public void add(){
        System.out.println("add.............");

    }
}

3.进行通知的配置
（1）Spring中开启注解扫描
（2）试用注解创建USer和UserProxy对象
（3）在增强类上面添加注解@Aspect

//导入@Aspect所需要的包
       <dependency>
            <groupId>org.aopalliance</groupId>
            <artifactId>com.springsource.org.aopalliance</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/com.springsource.org.aspectj.weaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>com.springsource.org.aspectj.weaver</artifactId>
            <version>1.6.4.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/com.springsource.org.apache.commons.logging -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>com.springsource.org.apache.commons.logging</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.log4j/com.springsource.org.apache.log4j -->
        <dependency>
            <groupId>org.apache.log4j</groupId>
            <artifactId>com.springsource.org.apache.log4j</artifactId>
            <version>1.2.16</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>

（4）Spring中开启生成代理对象

 <!-- 开启Aspect 生成代理对象一>
  <aop:aspecti autoproxy </aop:aspecti autoproxy>

4.配置不同类型的通知
（1）在增强类中，在作为通知的方法上面添加通知类型的注解，使用切入点表达式配置内容

package com.AOPanno;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect//生成代理对象
public class UserProxy {

    //Before就表示前置通知，
    @Before(value = "execution(* com.AOPanno.User.add(..))")
    public void befor(){
        System.out.println("before.....");
    }
}

AspectJ的注解的使用

package com.AOPanno;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect//生成代理对象
public class UserProxy {

    //Before就表示前置通知，
    @Before(value = "execution(* com.AOPanno.User.add(..))")
    public void befor(){
        System.out.println("before.....");
    }
    //又叫最终通知，有没有异常都执行
    @After(value = "execution(* com.AOPanno.User.add(..))")
    public void after(){
        System.out.println("after.....");
    }
    //after是在方法之后执行，AfterReturning是在放回结果之后执行
    //AfterReturning 后置通知，有异常不执行
    @AfterReturning(value = "execution(* com.AOPanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }
    //异常通知，add方法有异常时执行。
    @AfterThrowing(value = "execution(* com.AOPanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.....");
    }

    @Around(value = "execution(* com.AOPanno.User.add(..))")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前.....");
        proceedingJoinPoint.proceed();//被环绕的方法

        System.out.println("环绕之后.....");
    }
}

公共切入点的抽取
如上有多个重复的切入点

    //抽取公共切入点
    @Pointcut(value ="execution(* com.AOPanno.User.add(..))" )
    public void pointcut(){
        
    }

    //Before就表示前置通知，
    //抽取完公共切入点直接使用方法即可
    @Before(value = "pointcut()")
    public void befor(){
        System.out.println("before.....");
    }

6.有多个增强类，设置优先级
（1）在增强类上加注解@oder（），里面加上值，值越小，优先级越大
7.完全注解开发配置AspectJ

@Configuration//这个注解表示当前类为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.*"})//等于配置类中的扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启AspectJ生成代理对象
// 注解扫描生成代理对象；默认为false关闭扫描，开启为true，
public class SpringConfig {

}

鱼雨羽

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
IDEASpring2：AOP的AspectJ、切入点抽取、纯注解使用

AOP面向切面编程降低耦合不修改源代码的方式添加新功能，仅添加对应模块。原理：动态代理（1）有两种情况的动态代理1.1有接口interface的情况，要使用JDK中的动态代理有接口的时候，创建接口实现类的代理对象，通过代理对象来增强方法。1.2没有接口的情况，使用CGLIB中的动态代理。创建当前类子类的代理对象JDK动态代理Proxy类的方法创建代理对象调用newProxyInstance方法，方法三个参数：类加载器、类实现的接口可多个，实现接口写增强的部分。编写JDK动态代理
复制链接

扫一扫