小工具知识网

当前位置: 首页 > 行业知识 > AOP的使用(详细讲解)

行业知识

AOP的使用(详细讲解)

2026-11-19 00:55:48 来源:互联网转载

文章目录

    • 一、AOP基本概念
      • 1、什么是AOP
      • 2、AOP的作用
      • 二、AOP底层原理
      • 三、AOP的JDK动态代理
          • 1、使用JDK动态代理,使用Proxy类里面的方法创建代理对象
          • 2、编写JDK动态代理代码
          • 四、AOP术语
              • 1、连接点
              • 2、切入点
              • 3、通知(增强)
              • 4、切面
              • 五、AOP操作(准备)
                  • 1、Spring框架一般都是基于AspectJ实现AOP操作
                  • 2、基于AspectJ实现AOP操作
                  • 3、在项目工程里面引入AOP相关依赖
                  • 4、切入点表达式
                  • 六、AOP操作(AspectJ注解)【重点】
                      • 1、创建类,在类里面定义方法
                      • 2、创建增强类(编写增强逻辑)
                      • 3、进行通知的配置
                      • 4、配置不同类型的通知
                      • 5、相同的切入点抽取
                      • 6、有多个增强类多同一个方法进行增强,设置增强类优先级
                      • 7、完全使用注解开发
                      • 七、AOP操作(AspectJ配置文件)
                          • 1、创建两个类,增强类和被增强类,创建方法
                          • 2、在spring配置文件中创建两个类对象
                          • 3、在spring配置文件中配置切入点
                          • 4、���试代码

                            一、AOP基本概念

                            1、什么是AOP

                            (1)面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而是的业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

                            (2)通俗描述:不通过修改源代码方式,在主干功能里面添加新功能

                            (3)使用登录的例子说明AOP

                            2、AOP的作用

                            提供声明式事务;允许用户自定义切面

                            以下名词需要了解下:

                            • 横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
                            • 切面(ASPECT):横切关注点 被模块化 的特殊对象。即,它是一个类。
                            • 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。
                            • 目标(Target):被通知对象。
                            • 代理(Proxy):向目标对象应用通知之后创建的对象。
                            • 切入点(PointCut):切面通知 执行的 “地点”的定义。
                            • 连接点(JointPoint):与切入点匹配的执行点。

                              二、AOP底层原理

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

                              第一种:有接口情况,使用JDK动态代理;创建接口实现类代理对象,增强类的方法

                              第二种:没有接口情况,使用CGLIB动态代理;创建子类的代理对象,增强类的方法

                              三、AOP的JDK动态代理

                              1、使用JDK动态代理,使用Proxy类里面的方法创建代理对象

                              调用 newProxyInstance 方法,方法有三个参数:

                              public static Object newProxyInstance(ClassLoader loader,                                      Class[] interfaces,                                      InvocationHandler h)

                              方法有三个参数:

                              ​ 第一参数,类加载器

                              ​ 第二参数,增强方法所在的类,这个类实现的接口,支持多个接口

                              ​ 第三参数,实现这个接口 InvocationHandler,创建代理对象,写增强的部分

                              2、编写JDK动态代理代码

                              (1)创建接口,定义方法

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

                              (2)创建接口实现类,实现方法

                              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类创建接口代理对象

                              //创建代理对象代码public class UserDaoProxy implements InvocationHandler {    //把创建的是谁的代理对象,把谁传递过来    //有参构造传递    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;    }}
                              //使用 Proxy 类创建接口代理对象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 res = dao.add(1, 2);        System.out.println("result:"+res);    }}

                              .

                              四、AOP术语

                              1、连接点

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

                              2、切入点

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

                              3、通知(增强)

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

                              (2)通知有多种类型

                              • 前置通知
                              • 后置通知
                              • 环绕通知
                              • 异常通知
                              • 最终通知
                                4、切面

                                把通知应用到切入点过程

                                五、AOP操作(准备)

                                1、Spring框架一般都是基于AspectJ实现AOP操作

                                什么是AspectJ ?

                                AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作

                                2、基于AspectJ实现AOP操作

                                (1)基于xml配置文件实现

                                (2)基于注解方式实现(使用)

                                3、在项目工程里面引入AOP相关依赖
                                            org.springframework            spring-aspects            5.2.15.RELEASE                            org.aspectj            aspectjweaver            1.9.9                            aopalliance            aopalliance            1.0                                    org.aspectj            aspectjtools            1.9.9                            cglib            cglib            3.3.0        
                                4、切入点表达式

                                (1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强

                                (2)语法结构:

                                execution (【权限修饰符】【返回类型】【类全路径】【方法名称】(【参数列表】))

                                • 举例1:对com.jin.dao.UserDao类里面的add进行增强
                                  execution(* com.jin.dao.UserDao.add(..))
                                  • 举例2:对com.jin.dao.UserDao类里面的所有的方法进行增强
                                    execution(* com.jin.dao.UserDao.*(..))
                                    • 举例3:对com.jin.dao类里面所有类,类里面的所有的方法进行增强
                                      execution(* com.jin.dao.*.*(..))

                                      六、AOP操作(AspectJ注解)【重点】

                                      1、创建类,在类里面定义方法
                                      //被增强的类public class User {    public void add(){        System.out.println("add ...");    }
                                      2、创建增强类(编写增强逻辑)

                                      (1)在增强类里面,创建方法,让不同方法代表不同通知类型

                                      //增强类public class UserProxy {    //前置通知    public void before(){        System.out.println("before ...");    }}
                                      3、进行通知的配置

                                      (1)在spring配置文件中,开启注解扫描

                                          

                                      (2)使用注解创建User和UserProxy对象

                                      //被增强的类@Componentpublic class User {   ...}//增强类@Componentpublic class UserProxy {   ...}

                                      (3)在增强类上面添加注解@Aspect

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

                                      (4)在spring配置文件中开启生成代理对象

                                       
                                      4、配置不同类型的通知

                                      (1)在增加类的里面,通知方法上面添加通知类型注解,使用切入点表达式配置

                                      //增强类@Component@Aspect   //生成代理对象public class UserProxy {    //前置通知    //@Before注解表示作为前置通知    @Before(value = "execution(* com.jin.aopanno.User.add(..))")    public void before(){        System.out.println("before ...");    }    @AfterReturning(value = "execution(* com.jin.aopanno.User.add(..))")    public void afterReturning(){        System.out.println("afterReturning ...");    }    @After(value = "execution(* com.jin.aopanno.User.add(..))")    public void after(){        System.out.println("after ...");    }    @AfterThrowing(value = "execution(* com.jin.aopanno.User.add(..))")    public void afterThrowing(){        System.out.println("AfterThrowing ...");    }    @Around(value = "execution(* com.jin.aopanno.User.add(..))")    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {        System.out.println("环绕之前 ...");        proceedingJoinPoint.proceed();        System.out.println("环绕之后 ...");    }}

                                      .

                                      5、相同的切入点抽取
                                      //增强类@Component@Aspect   //生成代理对象public class UserProxy {//相同切入点抽取    @Pointcut(value = "execution(* com.jin.aopanno.User.add(..))")    public void pointdemo(){}        //前置通知    //@Before注解表示作为前置通知    @Before(value = "pointdemo()")    public void before(){        System.out.println("before ...");    }}    
                                      6、有多个增强类多同一个方法进行增强,设置增强类优先级

                                      (1)在增强类撒谎给你面添加注解@Order(数字类型值),数字类型值越小优先级越高

                                      @Component@Aspect   //生成代理对象@Order(1)  //优先级(数字值越小优先级越高)public class PersonProxy {   ...}
                                      7、完全使用注解开发

                                      (1)创建配置类,不需要创建xml配置文件

                                      @ComponentScan(basePackages = {"com.jin.pojo"})@Configuration@EnableAspectJAutoProxy(proxyTargetClass = true) //默认EnableAspectJAutoProxy为falsepublic class SpringConfig {}

                                      (2)测试代码

                                      @Test    public void MyTest01(){        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);        User user = context.getBean("user", User.class);        user.add();    }

                                      七、AOP操作(AspectJ配置文件)

                                      1、创建两个类,增强类和被增强类,创建方法
                                      //被增强类public class Book {    public void buy(){        System.out.println("buy ....");    }}//增强类public class BookProxy {    public void before(){        System.out.println("before ...");    }}
                                      2、在spring配置文件中创建两个类对象
                                       
                                      3、在spring配置文件中配置切入点
                                                                          
                                      4、测试代码
                                      @Test    public void MyTest(){        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");        Book book = context.getBean("book", Book.class);        book.buy();    }

上一篇:怎么样查到服务器?

下一篇:租服务器怎么连接ip账号?