Spring aop

面向切面编程

公共的 通用的 重复的代码快 单独拿出来 ,在需要调用的方法中通过动态代理的方式进行

静态代理

![1665881007796]

横向开发

(C:\Users\hqq\AppData\Roaming\Typora\typora-user-images\1665881007796.png)

/*
有接口和实现类时 先写接口
静态代理
一个接口
实现类和代理都要实现接口
实现类（目标对象）中实现具体业务功能
代理类中 ：成员变量为接口类型 为了实现目标对象的灵活切换
在构造方法参数用成员变量写入 是为了实现目标对象和代理的联系
重写的接口中
1.实现切面功能
2.调用目标对象的方法
3.实现切面功能
测试类调用
注意：是调用代理类（括号里是目标对象的实例）
 */
 第三个版本：
 该静态方法实现了业务功能的灵活切换 
 未实现切面功能的灵活切换
 
  public void test2(){
        Service service = new Agent(new ProductService());
        service.buy();
        }

第四个版本的实现

缺点：没有实现业务的动态代理

优点 实现了切面的灵活切换

上接口就是上灵活

该思想最大的特点就是

提取接口出来

在一个实现类中和接口灵活连接是通过 成员变量的引入，而不是直接实现接口

通过构造方法实现目标对象的注入

jdk8之后有个接口默认实现

接口默认实现 ：加了大括号，表示方法的空实现 做到不用实现全部方法，想实现那个接口就实现那个接口
 defalt 返回值 方法名（） { }
 */
public interface Aop {
    default void before(){}
   default void after(){ }
    default void exception(){}
}



测试类：
public void test3(){
        Service service = (Service) new com.test4.service.Agent(new com.test4.service.BookService(),new TranctionAop());
        
        
        Service service1 = new Agent(service,new RiziAop());
        这行代码实现了切面功能的添加  不断累加切面功能 即实现日志功能又实现事务功能
         service1.buy();

    }
}

第五个版本动态代理实现

1.方法的参数是 （接口类型参数）
2.返回的是 return Proxy.newProxyInstance(
3. 方法参数（类加载器，实现接口实现接口:，
代理功能实现（）{ 
 public Object invoke(
                               //生成的代理对象
                               Object proxy,
                               //正在被调用的目标方法
                               Method method,
    //目标方法的对象（继承后重写方法时,方法名，形参，返回值都不变
                               Object[] args) throws Throwable {

}
）
类加载器：反射机制加载类
实现接口:目标对象实现所有的接口 实现所有接口的方法
代理功能实现：采用匿名内部类方式实例化对象  



package com.test5;

import com.test5.aop.Aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class AgentFoctory {
    public static Object getAgent(Service service, Aop aop){
        //整个是个动态代理
           return Proxy.newProxyInstance(
                   //类加载器
                   service.getClass().getClassLoader(),
                   //目标对象实现所有的接口
                   service.getClass().getInterfaces(),
                   //代理功能实现
                   new InvocationHandler() {
                       @Override
                       public Object invoke(
                               //生成的代理对象
                               Object proxy,
                               //正在被调用的目标方法
                               Method method,
                               //目标方法的对象
                               Object[] args) throws Throwable {
                                  Object obj = null;
                        try {
                            //切面
                            aop.before();
                            //业务
                             obj = method.invoke(service,args);
                            //切面
                            aop.after();
                            //切面
                        }catch (Exception e){
                            aop.exception();
                        }


                           return obj;
                       }

                   }

           );
    }
}

spring 中aop的实现

aop常用术语

切面：通用的 。重复的，公共的功能 eg:日志，权限,事务

连接点：目标方法让业务功能和切面功能都实现 例如动态代理中 创建新方法 参数为业务功能和切面功能的接口，并在其中都调用（ 实现）

切入点：指定切入的位置，多个连接点构成切入点，（总体就是总体切面功能的实现）切入点可以是某个目标方法，类中的某个方法，也可以是某个包中的所有类中方法

目标对象：操作谁,谁就是目标对象，正在执行的对象

通知：指定切入的时间，是在目标方法执行前，执行后，出现异常后，还是环绕目标方法切入切面功能

ASpectJ