[Java] Java动态代理之拦截器的应用

/**
 * @auther: haozz
 * @date: 2018/5/27 22:15
 * @description:拦截器接口
 **/
public interface interceptor {
  boolean before(object proxy, object target, method method,object[] args);
  void around(object proxy,object target,method method,object[] args);
  void after(object proxy,object target,method method,object[] args);
}

• 3个方法的参数为：proxy代理对象、target真实对象、method方法、args运行方法参数；
  
• before方法返回boolean值，它在真实对象前调用。当返回为true时，则反射真实对象的方法；当返回为false时，则调用around方法；
  
• 在before方法返回为false的情况下，调用around方法
  
• 在反射真实对象方法或者around方法执行之后，调用after方法
  

/**
 * @auther: haozz
 * @date: 2018/5/27 22:48
 * @description:myinterceptor
 **/
public class myinterceptor implements interceptor{
  @override
  public boolean before(object proxy, object target, method method, object[] args) {
  system.out.println("反射方法前逻辑");
  return false;//不反射被代理对象原有方法
  }
  @override
  public void around(object proxy, object target, method method, object[] args) {
  system.out.println("取代了被代理对象的方法");
  }
  @override
  public void after(object proxy, object target, method method, object[] args) {
  system.out.println("反射方法后逻辑");
  }
}

/**
 * @auther: haozz
 * @date: 2018/5/27 22:30
 * @description:
 **/
public class interceptorjdkproxy implements invocationhandler {
  private object target;//真实对象
  private string interceptorclass = null;//拦截器全限定名
  public interceptorjdkproxy(object target,string interceptorclass){
  this.target = target;
  this.interceptorclass = interceptorclass;
  }
  public static object bind(object target,string interceptorclass){
  //取得代理对象
  return proxy.newproxyinstance(target.getclass().getclassloader(),
    target.getclass().getinterfaces(),
    new interceptorjdkproxy(target,interceptorclass));
  }
  @override
  /**
   * description:通过代理对象调用方法，首先进入这个方法
   * @auther: haozz
   * @param: proxy 代理对象
   * @param: method 被调用方法
   * @param: args 方法的参数
   * @return: java.lang.object
   * @date: 2018/5/27 23:00
   **/
  public object invoke(object proxy, method method, object[] args) throws throwable {
  if(interceptorclass == null){
    //没有设置拦截器则直接反射原有方法
    return method.invoke(target,args);
  }
  object result = null;
  //通过反射生成拦截器
  interceptor interceptor = (interceptor) class.forname(interceptorclass).newinstance();
  //调用前置方法
  if(interceptor.before(proxy,target,method,args)){
    //反射原有对象方法
    result = method.invoke(target,args);
  }else{//返回false执行around方法
    interceptor.around(proxy,target,method,args);
  }
  //调用后置方法
  interceptor.after(proxy,target,method,args);
  return result;
  }
}

• 开发者只要知道拦截器的作用就可以编写拦截器了，编写完后可以设置拦截器，这样就完成了任务，所以对于开发者而言相对简单了
  
• 设计者可能是精通java的开发人员，他来完成动态代理的逻辑
  
• 设计者只会把拦截器接口暴露给开发者使用，让动态代理的逻辑在开发者的视野中“消失”
  

public class mytest {
  public static void main(string []args){
  helloworld proxy1 = (helloworld) interceptorjdkproxy.bind(new helloworldimpl(),"com.csdn.blog.interceptor.myinterceptor");
  proxy1.sayhelloworld();
  }
}

反射方法前逻辑
取代了被代理对象的方法
反射方法后逻辑