巧用动态代理实现程序容错处理

 1.浅谈容错

      先简单谈一下容错技术，为了保证系统的高可用，以及高可靠性，系统的设计者通常会在关键技术环节实行一定的容错技术，保证系统在运行的过程中，一旦出现问题和异常，系统可以自动恢复功能。

 

      那么怎样才能实现容错呢？其实容错根本解决途径在于冗余，正所谓万变不离其宗，如果你有兴趣可以参考一些专门讲授容错技术的书籍，以及论文，你会发现他们讲授的解决方案，基本上都是采用各种冗余技术，实现容错处理的。

 

      对于冗余而言，其实可以分为两种，一种是物理冗余，这种冗余在自然界很常见，例如人有两只眼睛，两只耳朵，两双手，一旦其中一个部位发生问题，还有另外一个部位可以使用。在系统设计领域，常见很多机器关键部位的设计都有备份元器件，一旦发生问题，备份元器件可以接着实现原有功能。对于可靠性要求比价高的领域，典型的如航天，军事，通常关键的软件设计采用n版本的方式，有不同的程序员对同一功能进行开发，对于相同输入结果实行表决机制，认为输出结果占多数一致的情况是正常输出数据。

 

      另外一种冗余叫做时间冗余，一旦发生问题，系统重新再次执行，保证系统在多次尝试的情况下，恢复正常功能。简单的例子例如，一些基于消息的异步处理系统，一旦系统检测到消息发送异常，会尝试重新发送消息。

 

2.简述动态代理

      众所周知，代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

 

      Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。

 

      java的动态代理包含以下相关接口和类：

      1.java.lang.reflect.Proxy，提供了一组静态方法来为一组接口动态地生成代理类及其对象

      2.java.lang.reflect.InvocationHandler，调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

      详细的动态代理的知识可以参考各种网上的资源，例如：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/

 

3.如何使用动态处理进行容错

      正所谓遇到问题要对症下药，本篇文章讲述的方法不是包治百病的灵丹妙药，也是对于一些特定问题而产生的，现在描述一下具体的问题情况：处理的异常情况只包含可恢复性异常，什么是可恢复性异常呢？举例来说，例如远程调用经常会出现的超时异常，以及有网络不稳定等原因引起的网络服务，如FTP服务引起的连接异常等。

 

      每当程序当中遇到这些异常情况时，如果程序不做特殊处理，通常会将异常抛出，导致程序运行失败。其实，如果程序再重新执行多遍的话，这些异常很可能并不会再次发生，并顺利执行完程序。因此，针对可恢复性异常这种特点，我们采用时间容错的方式，每当异常发生时，重新执行，在有限次数内，通过某次顺利的执行，完成程序应有的功能。

 

      下面我们将看几段代码，因为可恢复性异常比较难再现，因此，我们使用特定的方法（随机数模拟）模拟可恢复性异常，用以说明问题。

 

1。要调用的方法接口FaultTolerantDemoService

 

package test.interfaces; public interface FaultTolerantDemoService { public void methodA() throws Exception; public void methodB() throws Exception; public void methodC() throws Exception; public void methodD() throws Exception; public void methodE(); public void methodF(); }

 

 

 2。要调用的方法实现FaultTolerantDemoServiceImpl

package test.impl; import test.interfaces.FaultTolerantDemoService; public class FaultTolerantDemoServiceImpl implements FaultTolerantDemoService { public void methodA() throws Exception { this.simualteException(); } public void methodB() throws Exception { this.simualteException(); } public void methodC() throws Exception { this.simualteException(); } public void methodD() throws Exception { this.simualteException(); } public void methodE() { } public void methodF() { } // 模拟异常发生 private void simualteException() throws Exception { int happenExceptionNum = (int) (Math.random() * 3); // 只有随机产生的数字小于2，才会发生异常 if (happenExceptionNum < 2) { throw new Exception("Exception happen"); } } }

 

3。动态代理容错工具类

package test.utils; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.HashSet; import java.util.Set; public class FaultTolerantUtil implements InvocationHandler { private Object delegation; private static final Set<String> methodSet = new HashSet<String>(); private static final int TRY_NUM_FOR_EXECUTE = 20; // 只针对需要作容错的方法进行容错 static { methodSet.add("methodA"); methodSet.add("methodB"); methodSet.add("methodC"); methodSet.add("methodD"); } public Object bind(Object delegation) { this.delegation = delegation; return Proxy.newProxyInstance(delegation.getClass().getClassLoader(), delegation.getClass().getInterfaces(), this); } public Object invoke(Object proxy, Method method, Object[] obj) throws Throwable { int tryNum = 0; Object result = null; boolean operateSueecss = true; while (tryNum < TRY_NUM_FOR_EXECUTE) { try { operateSueecss = true; result = method.invoke(delegation, obj); } catch (Exception e) { operateSueecss = false; System.out.println("Execute method: " + method.getName() + " failed!"); } if (methodSet.contains(method.getName()) && !operateSueecss) { // 延迟再取进行尝试 Thread.sleep(1000); System.out.println("The number of trying to Execute is method: " + method.getName() + " " + ++tryNum); } else { break; } } // 如果在有限的重试机制下，还未克服异常问题，干脆将异常抛出 if (!operateSueecss) { String errorString = "Finally execute method: " + method.getName() + " failed!"; System.out.println(errorString); throw new Exception(errorString); } return result; } }

 

4。调用方法演示

package test; import test.impl.FaultTolerantDemoServiceImpl; import test.interfaces.FaultTolerantDemoService; import test.utils.FaultTolerantUtil; public class TestFaultTolerantDemo { public static void main(String[] args) { // FaultTolerantDemoService ftpFlowService = new FaultTolerantDemoServiceImpl(); // 用以下方式，代替FaultTolerantDemoService ftpFlowService = new FaultTolerantDemoServiceImpl(),实现动态代理方式的service方法的创建 FaultTolerantUtil faultTolerantUtil = new FaultTolerantUtil(); FaultTolerantDemoService ftpFlowService = (FaultTolerantDemoService) faultTolerantUtil.bind(new FaultTolerantDemoServiceImpl()); // 方法调用 try { ftpFlowService.methodA(); ftpFlowService.methodB(); ftpFlowService.methodC(); ftpFlowService.methodD(); ftpFlowService.methodE(); ftpFlowService.methodF(); } catch (Exception e) { System.out.println("Can not run program normally"); } System.out.println("Run program normally"); } }

 

程序输出结果：

 

 Execute method: methodB failed! The number of trying to Execute is method: methodB 1 Execute method: methodB failed! The number of trying to Execute is method: methodB 2 Execute method: methodC failed! The number of trying to Execute is method: methodC 1 Run program normally

 

使用动态代理进行容错处理的优点：

1、代码侵入性小，代码的逻辑业务和容错处理部分比较分明，用户改动业务代码时，不用过分考虑容错部分代码的影响。

2、如果需要容错的方法数量比较多时，可以非常有效的节省代码的编写工作量，最大程度上做到代码的重用。

 

使用动态代理进行容错处理的缺点：

1、受动态代理机制本身属性的影响，必须编写方法实现的接口，有一定程度上制约。