尚硅谷学习笔记 AOP

尚硅谷AOP

AOP(概念)

1.什么是AOP

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

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

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

AOP(底层原理)

1. AOP底层使用动态代理

   (1)有两种情况动态代理

   第一种 有接口情况,使用JDK动态代理

   • 创建接口实现类的代理对象,增强类的方法

   第二种 没有接口情况,使用CGLIB动态代理

   • 创建当前类子类代理对象,增强类的方法

2. AOP(JDK动态代理)

   第一步 使用JDK动态代理,使用Proxy类方法创建对象

   (1)调用newProxyInstance方法

   • class类 Proxy() 中 (查api)

     static Object

     newProxyInstance(ClassLoader loader, 类[] interfaces, InvocationHandler h) 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

   • 第一个参数,类加载器

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

   • 第一个参数,实现这个接口InvocationHandler,创建代理对象,写增强的方法;

   第二步:编写JDK动态代码

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

   package com.atguigu.spring5.Dao;
   
   public interface UserDao {
   
       public  int add(int a, int b);
       public String  update(String id);
   }
   
   

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

   package com.atguigu.spring5.Dao.impl;
   
   import com.atguigu.spring5.Dao.UserDao;
   
   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类创建接口的代理对象

   • 创建代理对象的两种方式

     //匿名内部类
     Class[] interfaces={UserDao.class};
             Proxy.newProxyInstance(JDKProxy.class.getClassLoader()
                     , interfaces, new InvocationHandler() {
                         @Override
                         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                             return null;
                         }
                     });
     

     //创建对象实现接口
     package com.atguigu.spring5.test;
     
     import com.atguigu.spring5.Dao.UserDao;
     
     import java.lang.reflect.InvocationHandler;
     import java.lang.reflect.Method;
     import java.lang.reflect.Proxy;
     
     public class JDKProxy {
         public static void main(String[] args) {
             //创建是实现类类的代理对象
             Class[] interfaces={UserDao.class};
             Proxy.newProxyInstance(JDKProxy.class.getClassLoader()
                     , interfaces, new UserDaoProxy() );
         }
     }
     //创建代理对象代码
     class UserDaoProxy implements InvocationHandler{
         //写增强的逻辑
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
             return null;
         }
     }
     
     

   • 代码

     package com.atguigu.spring5.test;
     
     import com.atguigu.spring5.Dao.UserDao;
     import com.atguigu.spring5.Dao.impl.UserDaoImpl;
     
     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[] 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;
         }
     
     
     
     
         //写增强的逻辑
         @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;
         }
     }
     
     

3. AOP术语

   (1)连接点

   • 类的那些方法可以被增强,这些方法为连接点

   (2)切入点

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

   (3)通知(增强):

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

   • 通知有多种类型

     (1)前置通知

     (2)后置通知

     (3)环绕通知

     (4)异常通知

     (5)最终通知

   (4)切面

   • 把通知应用到切入点过程

   AOP操作(准备)

   1. spring框架一般都是基于AspectJ实现AOP操作

      (1)什么是AspectJ

      *AspectJ不是Spring组成部分,独立AOP框架,一般吧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.atguigu.dao.BookDao.(…) )

      • 举例三:对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强

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

   AOP操作(AspectJ注解)

   1. 创建类,在类里面定义方法

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

   2. 创建增强类(编写你增强的逻辑)

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

      //增强类
      public class UserProxy {
          //前置通知
          public  void  before(){
              System.out.println("before.......");
          }
      }
      

   3. 进行通知的配置

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

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

         package com.atguigu.spring5.aopanno;
         
         import org.springframework.stereotype.Component;
         
         //被增强类
         @Component
         public class User {
             public void  add(){
                 System.out.println("add.........");
             }
         
         }
         
         

         package com.atguigu.spring5.aopanno;
         
         import org.springframework.stereotype.Component;
         
         //增强类
         @Component
         public class UserProxy {
             //前置通知
             public  void  before(){
                 System.out.println("before.......");
             }
         }
         
         

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

         package com.atguigu.spring5.aopanno;
         
         import org.aspectj.lang.annotation.Aspect;
         import org.springframework.stereotype.Component;
         
         //增强类
         @Component
         @Aspect //生成代理对象
         public class UserProxy {
             //前置通知
             public  void  before(){
                 System.out.println("before.......");
             }
         }
         
         

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

   4. 配置不同类型的通知

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

      package com.atguigu.spring5.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.atguigu.spring5.aopanno.User.add(..))")
          public  void  before(){
              System.out.println("before.......");
          }
          @After(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
          public  void  after(){
              System.out.println("after.......");
          }
          @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("环绕之后.......");
          }
      }
      
      

   5. 相同的切入点抽取

      package com.atguigu.spring5.aopanno;
      
      import org.aspectj.lang.ProceedingJoinPoint;
      import org.aspectj.lang.annotation.*;
      import org.springframework.stereotype.Component;
      
      
      //增强类
      @Component
      @Aspect //生成代理对象
      public class UserProxy {
          //相同的切入点进行抽取
          @Pointcut(value="execution(* com.atguigu.spring5.aopanno.User.add(..))" )
          public void pointdemo(){
      
          }
      
      
          //前置通知
          //before注解作为表示为前置通知
          @Before(value="pointdemo()")
          public  void  before(){
              System.out.println("before.......");
          }
          @After(value="pointdemo()")
          public  void  after(){
              System.out.println("after.......");
          }
          @AfterReturning(value="pointdemo()")
          public  void  afterReturning(){
              System.out.println("afterReturning.......");
          }
          //异常通知
          @AfterThrowing(value="pointdemo()")
          public  void  afterThrowing(){
              System.out.println("AfterThrowing.......");
          }
          //环绕通知.
          @Around(value="pointdemo()")
          public  void  around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
              System.out.println("环绕之前.......");
              //被增强的方法执行
              proceedingJoinPoint.proceed();
              System.out.println("环绕之后.......");
          }
      }
      
      

   6. 有多个增强类对同一个方法进行增强,可以设置增强类的优先级

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

      @Component
      @Aspect
      @Order(1)
      public class PersonProxy {
      

   7. 完全注解开发

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

      @Configuration
      @ComponentScan(basePackages = {"com.atguigu"})
      @EnableAspectJAutoProxy(proxyTargetClass = true)
      public class configAop {
      

   AOP操作(AspectJ配置文件)

   1. 创建两个类,增强类和被增强类,创建方法

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

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