学习笔记——Spring(二)AOP和动态代理

AOP

什么是AOP

(1)面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

(2)通俗描述:不修改源代码添加功能

动态代理

引入

1.对实现类进行修改添加功能需要修改大量源码,不利已开发

2.由1引出了静态代理,静态代理就是在用代理类来扩展实现类如

//抽象角色：租房
public interface Rent {
    public void rent();
}

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

//代理角色：中介
public class Proxy implements Rent {
 
    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }
 
    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

缺点：扩展类多了 , 工作量变大了 , 开发效率降低 .

由此引入动态代理

例子和源码分析

InvocationHandler接口：调用处理程序对代理实例进行处理

invoke(Object proxy,Method method,Object[] args)`

​ 在代理实例上处理方法调用并返回结果。代理实例使用方法通过调用该方法

Proxy类 : 为创建代理实例提供方法

newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

ClassLoader：类加载器

interfaces：类实现的接口

InvocationHandler:处理代理实例的InvocationHandler的实例

//抽象角色：租房
public interface Rent {
    public void rent();
}

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;
 
    public void setRent(Rent rent) {
        this.rent = rent;
    }
 
    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }
 
    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
 
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
 
}

//租客
public class Client {
 
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }
 
}

底层的个人理解：

1.创建代理实例来代理对象—newProxyInstance方法

2.代理实例调用方法时,反射得到method对象，传入InvocationHandler中的invoke函数中，利用反射中的方法method.invoke()来实现方法的调用。此时方法被抽象成方法对象，在方法对象前后加新方法完成方法的功能增强。所以之后调用方法都会在前后调用新方法。

反射的理解：

jvm运行时创建对象和调用方法和属性，而不是编译阶段，动态的。

复用性：

new创建对象和执行方法必须在代码中写死。反射是动态的，比如ioc的getBean根据不同的bean的id创建具体实例，jdk动态代理的invoke方法中method.invoke根据调用的不同方法具体执行。一段代码动态的执行多种情况。

解耦合

ioc创建实例读取xml文件不需要硬编码。

抽象性：

rpc远程调用，根据服务信息在找到注册中心的实例，根据实例的method和object通过反射进行执行。将方法抽象存储便于调用。

底层原理

AOP底层使用动态代理

两种情况：

​ 有接口:JDK动态代理

​ 创建接口实现类的代理对象

​ 无接口:没有接口情况,使用CJLIB动态代理

​ 创建子类的代理对象

AOP术语

​ 1.连接点 :类里可以被增强的方法

​ 2.切入点：实际被增强的方法

​ 3.通知(增强)：

​ (1)增强的逻辑

​ (2)多种类型

​ 前置通知:在切入点前执行

​ 后置通知:在切入点后执行

​ 环绕通知:前后都执行

​ 异常通知:切入点发生异常

​ 最终通知:无论发生异常与否都会执行，类似try-catch-finally中的finally

​ 4.切面

​ 是动作：把通知应用到切入点就是切面

AOP操作基础

AspectJ

​ Spring 框架一般基于AspectJ

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

基于AspectJ实现AOP操作

​ (1)基于xml配置文件

​ (2)基于注解方式(使用)

切入点表达式

​ (1)作用：知道对哪个类的哪个方法进行增强

​ (2)语法结构：execution(权限修饰符如public 返回类型 类全路径 方法名 参数列表)

举例1：对com.atguigu.dao.BookDao类的add进行增强

​ execution(*com.atguigu.dao.BookDao.add(…)) 修饰符用 * 返回类型可省略 参数列表用…

举例2：对com.atguigu.dao.BookDao类的所有方法进行增强

​ execution(com.atguigu.dao.BookDao.(…))

AOP注解操作

1.开启注解扫描,配置上在原来的基础上加几个aop网址

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-context-4.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd">
    
    <context:component-scan base-package="practice01">

    </context:component-scan>
        //开启生成代理对象
      <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2.在增强的类和被增强的类加注解

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

//被增强的类
@Component
public class User {}

3.编写增强逻辑

//4、配置不同类型的通知
@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.........");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知
    @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("环绕之后.........");
    }
}

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

//（1）在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{ }

AOP 操作（AspectJ 配置文件)

xml一般不常使用

<!--1、创建两个类，增强类和被增强类，创建方法（同上一样）-->
<!--2、在 spring 配置文件中创建两个类对象-->
<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
<!--3、在 spring 配置文件中配置切入点-->
<!--配置 aop 增强-->
<aop:config>
 <!--切入点-->
 <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
 <!--配置切面-->
 <aop:aspect ref="bookProxy">
 <!--增强作用在具体的方法上-->
 <aop:before method="before" pointcut-ref="p"/>
 </aop:aspect>
</aop:config>

​