关于Java静态代理模式的实现

在java中有两类代理模式,动态代理模式和静态代理模式,关于动态代理的实现,涉及到字节码的重新编写,无法单纯的通过java代码实现,不过jdk内置实现了动态代理模式,基于接口的,其它的有cglib,aspectJ等,这里不献丑了.
之所以有动态代理的出现,主要是因为静态代理不够灵活,这里相对传统的静态代理模式进行一下改进,使我们能方便快捷的使用代理的设计思想,同时有不需要大量冗余的代码.
话不多说,先看一个传统的代理模式的实现:
//接口
public interface HelloService {
 
 void sayHello(String name);

}
//接口实现
public class HelloSerivceImpl  implements HelloService{

 @Override
 public void sayHello(String name) {
  Console.writeLine("Hi~,glad to meet U,"+name);
 
 }

}

//代理实现
public class HelloServiceProxy implements HelloService{

 private HelloService service;
 
 public HelloServiceProxy(HelloService service){
  this.service=service;
 }
 @Override
 public void sayHello(String name) {
  Method m=service.getClass().getDeclaredMethod("sayHello", String.class);
  this.before(service, m, new Object[]{name});
  service.sayHello(name);
  this.before(service, m, new Object[]{name});
 
 }

 public void after(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>after the method of " +  method.getName());
 
 }

 public void before(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>before the method of " + method.getName());

 
 }

}

//测试
static void test_static(){
 HelloService service=new HelloServiceProxy(new HelloSerivceImpl());
 service.sayHello("lining");
}

 

从上面我们可以看,代理的接口实现实际上是调用接口实例的对应方法,并且在其执行之前调用before方法,在执行后调用after方法,从而实现拦截器的效果.但是当接口的方法很多的时候,我们需要对每个方法重复上面的过程,这将充满重复的代码段,增加我们的工作量,为此我们又必须对其进行改造和优化.

 

从上面我们可以看出,代码重复的地方在于before和after方法,而且两个方法是分开的,能想到的一个简单的改进方法就是将方法名作为参数传递过去,进行调用,于是我们这里抽象出来一个统一执行的方法:

public class HelloServiceProxy implements HelloService {

 private HelloService service;

 public HelloServiceProxy(HelloService service) {
  this.service = service;
 }

 @Override
 public void sayHello(String name) {
  invoke("sayHello", name);
 }

 public void after(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>after the method of " +  method.getName());
 }

 public void before(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>before the method of " + method.getName());
 
 }

 private Object invoke(String name, Object... params) {
  Object result = null;
  try {
   Class<?>[] types = new Class[params.length];
   for (int i = 0; i < types.length; types[i] = params[i++].getClass())
    ;
   Method m = service.getClass().getDeclaredMethod(name, types);
   this.before(service,m, params);
   result = m.invoke(service, params);
   this.after(service,m, params);

  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
}

 

从上面的代码我们可以看到,比最初的模式有了一定的改进,所有调用接口的方法统一起来的,所不同的仅仅是传递参数的不同,然而,能不能更进一步的,毕竟传递的方法名称是硬编码的,即使写错了,编译器也检测不出来.如果能够有一种方法可以自动获取方法名称,而我们仅需要提供方法参数岂不是更好?在这种想法的指导下,我们再进一步改进:

 

public class HelloServiceProxy implements HelloService {

 private HelloService service;

 public HelloServiceProxy(HelloService service) {
  this.service = service;
 }

 @Override
 public void sayHello(String name) {
  invoke(name);
 }

 public void after(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>after the method of " +  method.getName());
 }

 public void before(Object target, Method method, Object[] params) {
  System.out.println(">>>>>>before the method of " + method.getName());
 
 }

 private Object invoke(Object... params) {
  Object result = null;
  String methodName = MethodTool.getCallerMethodName(1);
  try {
   Class<?>[] types = new Class[params.length];
   for (int i = 0; i < types.length; types[i] = params[i++].getClass())
    ;
   Method m = service.getClass().getDeclaredMethod(methodName, types);
   this.before(service,m, params);
   result = m.invoke(service, params);
   this.after(service,m, params);

  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
}

 

到这里,我们基本上解决了有代码冗余的问题,这里有一个关键点,就是标红的代码段:

  String methodName = MethodTool.getCallerMethodName(1);
这段代码的意思获取调用当前方法的方法名称,是我封装的类库中的方法,不同人可以有自己不同的实现.

 

上面的代码适用于多数代理的情况,因此我们可以抽象出来一个基类,并将before和after方法抽象成拦截器接口,于是上面的代码可以改造成如下:

 

/**
 * 静态代理模式的抽象类<br>
 * 该类不能独立使用,而是应当继承某个接口以后作为接口类型使用<br>
 * 该类没有默认的构造方法,子类在实例化时需要显示调用该类的构造方法并提供构造参数<br>
 * 由于父类的实例化先于子类,父类初始化时子类的实例成员尚未初始化,因此子类使用其实例成员变量作为父类的构造参数<br>
 *
 * @author skyfalling
 *
 */
public abstract class AbstractProxy {

 /**
  * 被代理对象实例
  */
 private Object target;
 /**
  * 拦截器实例
  */
 private Interceptor interceptor;

 /**
  * 获取拦截器实例
  *
  * @return
  */
 protected Interceptor getInterceptor() {
  return interceptor;
 }

 /**
  * 设置拦截器实例<br>
  * 子类可以重置拦截器
  *
  * @param interceptor
  */
 protected void setInterceptor(Interceptor interceptor) {
  this.interceptor = interceptor;
 }

 /**
  * 构造方法,传递被代理实例,参数由子类在实例化时提供<br>
  * 这里需要注意的是,被代理的对象与该类的子类应该拥有相同的接口
  *
  * @param target
  *            被代理对象实例
  * @param interceptor
  *            拦截器实例
  */
 protected AbstractProxy(Object target) {
  this(target, null);
 }

 /**
  * 构造方法,传递被代理实例和拦截器,参数由子类在实例化时提供<br>
  * 这里需要注意的是,被代理的对象与该类的子类应该拥有相同的接口
  *
  * @param target
  *            被代理对象实例
  * @param interceptor
  *            拦截器实例
  */
 protected AbstractProxy(Object target, Interceptor interceptor) {
  this.target = target;
  this.interceptor = interceptor;
 }

 /**
  * 执行被代理对象中和调用者同名的方法<br>
  * 调用该方法时,将会触发被代理对象的同名方法,并且在被代理对象方法执行过程中使用拦截器进行拦截处理
  * 子类在接口实现中调用该方法,并传递参数,从而实现对代理对象的拦截处理<br>
  *
  * @param target
  * @param params
  * @return 返回代理结果
  */
 protected Object proxy(Object... args) {
  String methodName = MethodTool.getCallerMethodName(1);
  Object result = null;
  try {
   Class<?>[] types = new Class[args.length];
   for (int i = 0; i < types.length; types[i] = args[i++].getClass())
    ;
   // 被代理的方法
   Method method = this.target.getClass().getDeclaredMethod(
     methodName, types);

   // 代理前的处理
   if (this.interceptor != null) {
    this.interceptor.before(this.target, method, args);
   }
   try {
    // 执行被代理的方法
    result = method.invoke(this.target, args);
   } catch (Exception ex) {
    this.interceptor.doException(this.target, method, args, ex);
   }
   // 代理之后的处理
   if (this.interceptor != null) {
    this.interceptor.after(this.target, method, args);
   }

  } catch (Exception e) {
   ExceptionHandler.throwException(e);
  }
  return result;
 }

}

 

/**
 * 拦截器的接口声明
 *
 * @author skyfalling
 *            拦截对象的类型
 *
 */
public interface Interceptor {

 /**
  * 拦截前处理
  *
  * @param target
  *            被代理的实例
  * @param method
  *            被代理的方法
  * @param args
  *            被代理方法的参数
  */
 void before(Object target, Method method, Object[] args);

 /**
  * 拦截后的处理
  *
  * @param target
  *            被代理的实例
  * @param method
  *            被代理的方法
  * @param args
  *            被代理方法的参数
  */
 void after(Object target, Method method, Object[] args);

 /**
  * 被拦截方法出现异常时的处理
  *
  *
  * @param target
  *            被代理的实例
  * @param method
  *            被代理的方法
  * @param args
  *            被代理方法的参数
  * @param ex
  *            异常实例
  */
 void doException(Object target, Method method, Object[] args,Exception ex);
}

在进行了上述的抽象后,我们利用基类重新实现静态代理模式:

 

//静态代理类继承父类,实现接口方法

public class HelloServiceProxy extends AbstractProxy implements HelloService {

 @Override
 public void sayHello(String name) {
  this.proxy(name);
 }
 public HelloServiceProxy(HelloService service) {
  super(service,new ProxyInterceptor() {
   @Override
   public void after(Object target, Method method, Object[] params) {
    System.out.println(">>>>>>after the method of " +  method.getName());
   
   }

   @Override
   public void before(Object target, Method method, Object[] params) {
    System.out.println(">>>>>>before the method of " + method.getName());

   
   }
  });
 }

 

//测试方法

 static void test_static(){
  HelloService service=new HelloServiceProxy(new HelloSerivceImpl());
  service.sayHello("lining");
 }

 

好了,我的关于静态代理模式的实现就是这样,以后实现代理的时候,只需继承静态代理的基类和代理对象的接口,对于接口中的方法实现中统一调用proxy方法即可.暂时能够优化的程度就到这了,如果进一步优化,恐怕需要动态改写字节码了,研究过javaassit的,可以考虑用它实现.

第一次发帖,如果哪里有错,欢迎批评指正,莫要拍砖!