Aop概念(重点)

1.什么是AOP(背)

  • 面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各个部分之间的耦合度降低,提高程序的可重用性,同时提高了开发效率
  • 通俗描述:不通过修改源代码方式,在主干功能里面添加新功能
  • 通过登录例子说明

7.png

AOP底层原理(要背)

1.AOP底层使用动态代理

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

8.png

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

9.png

AOP(JDK动态代理)

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

  • 使用newProxyInstans方法

11.png

  • 方法有三个参数:
    • 第一参数,类加载器
    • 第二参数,增强方法所在的类,这个类实现的接口,支持多个接口
    • 第三参数,实现这个接口InvocationHandler,创建代理对象,写增强的方法

JDK动态代理代码演示

  • 创建接口,定义方法

    1. public interface UserDao {
    2.   int add(int a, int b);
    4.   String update(String id);
    5. }

  • 创建接口实现类,实现方法

    1. public class UserDaiImpl implements UserDao{
    2.   public int add(int a, int b) {
    3.       return a+b;
    4.   }
    6.   public String update(String id) {
    7.       return id;
    8.   }
    9. }

  • 使用proxy类创建接口代理对象 ```java public class JDKProxy { public static void main(String[] args) {

    1.   //创建接口实现类代理对象
    2.   Class[] interfaces = {UserDao.class};
    3.   UserDaiImpl userDai = new UserDaiImpl();
    4.   UserDao userDao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDai));
    5.   //int result = userDao.add(1,2);
    6.   String s = userDao.update("33333");
    7.   System.out.println("result:"+s);

    } } //创建代理对象代码 class UserDaoProxy implements InvocationHandler {

    //1.把创建的是谁的代理对象,把谁传递过来 //有参数构造传递 private Object obj; public UserDaoProxy(Object obj){

    1.   this.obj = obj;

    }

  1. //增强的逻辑
  2. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  3.     //方法之前
  4.     System.out.println("方法之前执行...."+method.getName()+":传递的参数...."+ Arrays.toString(args));
  5.     //被增强的方法执行
  6.     Object res = method.invoke(obj, args);
  8.     //方法之后
  9.     System.out.println("方法之后执行"+obj);
  10.     return res;
  11. }

}

  1. 运行结果
  2. ```java
  3. 方法之前执行....update:传递的参数....[33333]
  4. 方法之后执行com.ranin.UserDaiImpl@27c170f0
  5. result:33333

AOP(术语)(要背)

1.连接点

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

2.切入点

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

3.通知(增强)

  • 实际增强的逻辑部分称为通知(增强)
  • 通知有多种类型
    • 前置通知
    • 后置通知
    • 环绕通知
    • 最终通知

4.切面

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

    AOP操作(准备)

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

  • 什么是AspectJ

    • AspectJ不是Spring组成部分,独立的AOP框架,一般把AspectJ和Spring框架一起来使用,进行AOP的相关操作
  • 基于AspectJ实现AOP操作
    • 基于xml配置文件
    • 基于注解方式实现(使用)

  • 在项目的工程中引入AOP相关的依赖

    • 一共需要导入的依赖
      1. <dependency>
      2. <groupId>org.springframework</groupId>
      3. <artifactId>spring-aspects</artifactId>
      4. <version>5.0.2.RELEASE</version>
      5. </dependency>
      6. <dependency>
      7. <groupId>org.springframework</groupId>
      8. <artifactId>spring-beans</artifactId>
      9. <version>5.2.8.RELEASE</version>
      10. </dependency>
      11. <dependency>
      12. <groupId>org.springframework</groupId>
      13. <artifactId>spring-core</artifactId>
      14. <version>5.2.8.RELEASE</version>
      15. </dependency>
      16. <dependency>
      17. <groupId>org.springframework</groupId>
      18. <artifactId>spring-context</artifactId>
      19. <version>5.2.8.RELEASE</version>
      20. </dependency>
      21. <dependency>
      22. <groupId>commons-logging</groupId>
      23. <artifactId>commons-logging</artifactId>
      24. <version>1.2</version>
      25. </dependency>
      26. <dependency>
      27. <groupId>org.springframework</groupId>
      28. <artifactId>spring-aop</artifactId>
      29. <version>5.2.8.RELEASE</version>
      30. </dependency>
      31. <dependency>
      32. <groupId>org.junit.jupiter</groupId>
      33. <artifactId>junit-jupiter</artifactId>
      34. <version>RELEASE</version>
      35. <scope>compile</scope>
      36. </dependency>

  • 切入点表达式

    • 切入点表达式的作用:知道对那个类里面的那个方法进行增强
    • 语法结构:
      • execution([权限修饰符][返回类型][类全路径][方法名称([参数列表]))
    • 类全路径举例:com.ranin.dao,BookDao
      • 举例1:对com.ranin.dao.BookDao中的add()方法进行增强
        • execution(* com.ranin.dao.BookDao.add(..)) 星号表示所有的修饰符,..表示参数列表
      • 举例2:对com.ranin.dao.BookDao中的所有方法增强
        • execution( com.ranin.dao.BookDao.(…))
      • 举例3:对com.ranin.dao包里面所有类,类里面所有方法都进行增强
        • execution( com.ranin.dao..*(..))

          AOP操作(AspectJ注解)

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

          ```java package com.ranin.aopano;

public class User { public void add(){ System.out.println(“add…..”); } }

  1. <a name="MEz1s"></a>
  2. ### 2.创建增强类(编写增强逻辑)
  4. - 在增强的类中,创建方法,让不同的方法代表不同通知类型
  5. ```java
  6. //增强类
  7. public class UserProxy {
  9.     //前置通知
  10.     public void before(){
  11.         System.out.println("before...");
  12.     }
  13. }

3.进行通知的配置

  • 在spring配置文件中,开启注解的扫描 ```xml <?xml version=”1.0” encoding=”UTF-8” ?>

  2. - 使用注解创建User和UserProxy对象
  3. - 把@Component注解添加到两个类上
  4. - 在增强的类上面添加注解@Aspect 表示要生成代理对象
  5. ```java
  6. @Aspect //表示要生成代理对象
  7. public class UserProxy {

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

    1. <!--开启Aspect生成代理对象
    2. aop:aspectj-autoproxy:会去类中寻找有没有@Aspect这个注解,如果有会给这个类生成一个代理对象
    3. -->
    4. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  • 配置不同类型的通知

    • 在增强类的里面,在作为通知方法上面添加通知类型的注解,并且使用切入点表达式配置

      1. //增强类
      2. @Component
      3. @Aspect //表示要生成代理对象
      4. public class UserProxy {
      6. //前置通知
      7. //@Before表示作为前置通知
      8. @Before(value = "execution(* com.ranin.aopano.User.add(..))")
      9. public void before(){
      10.    System.out.println("before...");
      11. }
      13. //最终通知,不管有没有发生异常都会通知
      14. @After(value = "execution(* com.ranin.aopano.User.add(..))")
      15. public void after(){
      16.    System.out.println("after....");
      17. }
      18. //后置通知,返回通知 当有异常不执行
      19. @AfterReturning(value = "execution(* com.ranin.aopano.User.add(..))")
      20. public void afterReturning(){
      21.    System.out.println("AfterReturning....");
      22. }
      23. //异常通知
      24. @AfterThrowing(value = "execution(* com.ranin.aopano.User.add(..))")
      25. public void afterThrowing(){
      26.    System.out.println("AfterThrowing....");
      27. }
      29. //环绕通知
      30. @Around(value = "execution(* com.ranin.aopano.User.add(..))")
      31. public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
      32.    System.out.println("环绕之前....");
      33.    //执行被增强方法
      34.    proceedingJoinPoint.proceed();
      35.    System.out.println("环绕之后");
      36. }
      37. }

      编写测试类 ```java public class TestDemo { @Test public void test1(){ ApplicationContext context = new ClassPathXmlApplicationContext(“bean1.xml”); User user = context.getBean(“user”, User.class); user.add(); }

}

  1. 运行结果
  2. ```java
  3. 环绕之前....
  4. before...
  5. add.....
  6. AfterReturning....
  7. after....
  8. 环绕之后

5.对相同切入点抽取

  1.  //对相同切入点进行抽取
  2. @Pointcut(value = "execution(* com.ranin.aopano.User.add(..))" )
  3. public void pointDemo(){
  5. }
  7. //前置通知
  8. //@Before表示作为前置通知
  9. @Before(value = "pointDemo()")
  10. public void before(){
  11.     System.out.println("before...");
  12. }

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

  • 在增强类的上面添加注解@Order(数字类型的值),这个值越小优先级越高
    1. //增强类
    2. @Component
    3. @Aspect //表示要生成代理对象
    4. @Order(1)
    5. public class UserProxy {

    AOP操作(AspectJ配置文件)

    1.创建两个类,一个增强类和被增强类,创建方法
    2.在spring的配置文件中创建两个对象
    3.在spring的配置文件中配置切入点 ```xml 

  1. <!--配置切面-->
  2. <aop:aspect ref="userProxy">
  3.     <!--增强作用在具体的方法上-->
  4.     <aop:before method="before" pointcut-ref="p"/>
  5. </aop:aspect>

  1. 纯注解配置
  2. ```java
  3. @Configuration
  4. @ComponentScan(basePackages = {"com.ranin"})
  5. @EnableAspectJAutoProxy(proxyTargetClass = true)//可以替代配置文件中的aop:aspectj-autoproxy
  6. public class ConfigAop {
  8. }