Spring Boot之AOP原理实现

Aop实现原理：拦截器+动态代理
Aop要做的事情：在真正的对象代码执行之前，做点什么，执行完之后，再做点什么，废话不多说，直接从代码开始讲起

ProxyBean的现实：

• 第一步：动态代理

  • JDK提供了·类Proxy：包含newProxyInstance方法

public statistic Object newProxyInstance(ClassLoader classLoadeer,Class<?>[] interface,InvocationHandler invocationHangler);//生成一个代理对象

• ClassLoader:类加载器

• interfaces:绑定的接口，也就是把代理对象绑定到哪些接口下，可以是多个

• invocationhandler:绑定代理对象逻辑实现

• invocationHandler对象定义了一个invoke方法：

public Object invoke(Object proxy,Method method,Object[] args){
    System.out.println("进入代理逻辑方法");
    System.out.println("在调度真实对象之前的服务");
    Object obj=method.invoke(target,args);//通过反射实现，调度真实对象
}

补充： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 详情见 https://www.jianshu.com/p/9be58ee20dee

• 第二部分拦截器：

  1 Intercepter：拦截器接口

 public interface Intercepter{
     //事前方法
     public boolean before();
     
     //事后方法
     public void after();
     
     /**
     *取代原有事情方法
     * @param invocation --回调参数，可以通过它的proceed方法，回调原有事件
     * @return 原有事件返回对象
     */
     public Object arround(Invocation invocation);
     
     //是否返回方法，事件没有异常时执行
     public void afterReturning();
     
     //时候异常方法,事件异常时执行
     public void afterThrowing();
     
     //是否使用around取代原有方法
     boolean useAround();
     
     
 }

2 invocation

   public class invocation{
       private Object[] param ;
       private Method method;
       private Object target;
       
       public Invocation(Object[] param,Method method,Object target){
          .....//构造函数
       }
       //反射方法
       public Object proceed() Throws Exception{
           return method.invoke(target,param);//以反射的形式去调用原有的方法
       }
           
   }

3 ProxyBean

Public class ProxyBean implement InvocationHandler{
    private Object target;//被代理对象
    private Interceptor interceptor=null;//拦截器
    
    //生成一个代理对象
    public statistic Object getProxyBean(Obeject targer,Interceptor interceptor){
        ProxyBean proxyBean=new ProxyBean();
        proxyBean.target=target;
        proxyBean.interceptor=interceptor;
        //生成代理对象
        Object proxy=Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxyBean);
        return proxy
    }
    
    //处理代理对象方法逻辑
    @Override
    public Object invoke(Object proxy,Method method,Object[] args){
        //异常标志
        boolean exceptionFlag=false;
        Invocation invocation=new Invocation(target,method,args);
        Object retobj=null;
        
        try{
            if(this.intercepter.before()){
                retobj=this.interceptor.aroud(invocation);
            }else{
                retObj=method.invoke(target,args);
            }
        }catch(Exception e){
            exceptionFlag=true;
        }
        this.interceptor.after();
        if(exceptionFlag){
            this.interceptor.afterThrowing();
        }else{
              this.interceptor.afterReturning();
              return retObj;
        }
        return null;
    }
}

• 说明：

  • 利用newProxyInstance()生成一个与被代理对象绑定了的代理对象
  • 实现InvocationHandler的invoke方法

• AOP：以上就是AOP的原理，一种约定流程的编程，将代码切开，植入一些我们需要的处理。比如我们可以拦截所有的业务代码，将他们统一的非业务切割出来，让代理去实现，这样开发者就可以专心于业务代码，其他的杂事都让代理去处理了。