一个常见问题的良好代码组织方式

一个好的程序员不仅仅编写的代码要能够正确的运行，而且要使编写的代码具有足够的可读性，不胡扯其他虚的，这里针对一个常见的问题提出一个比较良好的代码组织方式。

还是先看例子：

public class App {
	public static void main(String[] args) {
		/**
		 * 按照顺序执行，任何一个操作执行失败，后面的操作不再执行，类似于
		 * 如下这种代码组织方式：
		 */
		boolean success=false;
	   if(success){
		   success=test1();
	   }
	   if(success){
		   success=test2();
	   }
	   if(success){
		   success=test3();
	   }
	   
	   //if(success) do something
	   
	   /**
	    * 或者是这种组织方式,嵌套非常的深
	    * 
	    * if(success){
		   success=test1();
		   if(success){
			   success=test2();
			   if(success){
				   success=test3();
			   }
		   }
	   }
	    * 
	    */
	   
		
	}
	public static boolean test1() {
		//一些操作
		return false;
	}
	public static boolean test2() {
		//一些操作
		return false;
	}
	public static boolean test3() {
		//一些操作
		return false;
	}
}

这里有3个方法，需要顺序执行，实际过程中有可能会有3个以上甚至到达8-10个左右，每一步的执行都要根据上面一步方法取得的结果确定是否要继续执行下面的方法。代码可能的组织方式见上面。可见，3个方法每一步都进行了判断，感觉还算清晰，要是再多一些方法，或者每一步中再一些执行操作呢，可能看起来就不是那么好看了。再者一种方式一个执行失败了，流程还是会顺着一路判断下来，浪费CPU执行时间，另一种方式嵌套的确太深，看起来伤脑筋，那么有没有一种比较有效的方式来解决这个问题呢？答案是有的。

再看，首先构造一个任务执行接口：

/**
 * 
 * <p>
 * 要执行的任务
 * </p>
 * 
 * @author <a href="mailto:[e-mail]" mce_href="mailto:[e-mail]">清虚</a>
 * @since 2.0 2010-4-14下午04:46:18
 * 
 */
public interface Runnable {
	/**
	 * 
	 * 
	 * <p>
	 * 执行相应的任务
	 * </p>
	 * 
	 * @author <a href="mailto:[e-mail]" mce_href="mailto:[e-mail]">清虚</a>
	 * @since 2.0 2010-4-14下午04:46:52
	 * 
	 * @return true 执行成功
	 */
	boolean run();
}

紧接着，构造一个循环执行任务的执行器：

/**
 * 
 * <p>
 * 执行构建
 * </p>
 * 
 * @author <a href="mailto:[e-mail]" mce_href="mailto:[e-mail]">清虚</a>
 * @since 2.0 2010-4-14下午04:42:33
 * 
 */
public class Executor {
	/**
	 * 
	 * 
	 * <p>
	 * 按顺序执行runnable,如果任何一个runnable的run返回false，则停止执行后面的
	 * runnable，并返回已经执行成功的runnable数量
	 * </p>
	 * 
	 * @author <a href="mailto:[e-mail]" mce_href="mailto:[e-mail]">清虚</a>
	 * @since 2.0 2010-4-16下午12:58:07
	 * 
	 * @param runnables
	 * @return 执行成功的runnable数量
	 */
	public int execute(Runnable... runnables) {
		int i = 0;
		for (Runnable runnable : runnables) {
			if (!runnable.run()) {
				break;
			}
                       i++;
		}
		return i;
	}
}

如何使用呢？继续看：

public class App {
	public static void main(String[] args) {
		/**
		 * 按照顺序执行，任何一个操作执行失败，后面的操作不再执行，类似于
		 * 如下这种代码组织方式：
		 */
//		boolean success=false;
//	   if(success){
//		   success=test1();
//	   }
//	   if(success){
//		   success=test2();
//	   }
//	   if(success){
//		   success=test3();
//	   }
	   
	   //if(success) do something
	   
	   /**
	    * 或者是这种组织方式,嵌套非常的深
	    * 
	    * if(success){
		   success=test1();
		   if(success){
			   success=test2();
			   if(success){
				   success=test3();
			   }
		   }
	   }
	    * 
	    */
		
		//首先将要执行每一步任务构建好
		Runnable r1=new Runnable(){
			@Override
			public boolean run() {
				
				return test1();
			}
		};
		Runnable r2=new Runnable(){
			@Override
			public boolean run() {
				
				return test2();
			}
		};
		Runnable r3=new Runnable(){
			@Override
			public boolean run() {
				
				return test3();
			}
		};
	   
		//2.0 使用执行器顺序执行
		Executor e=new Executor();
		int num=e.execute(r1,r2,r3);
		if(num==3){
			System.out.println(true);
		}else{
			System.out.println("有部分任务是没有执行的。");
		}
		
	}
	public static boolean test1() {
		//一些操作
		return false;
	}
	public static boolean test2() {
		//一些操作
		return false;
	}
	public static boolean test3() {
		//一些操作
		return false;
	}
}

现在看起来如何呢？可能你会说代码量很多，是的，这个例子太简单，看起来是有点不划算，不过实际情况下，基本上每一步if(success)后面可能都有大量的任务需要执行，这时你就可以

得到这种代码组织方式的实惠了，代码模块化，不再执行不必要的判断逻辑，一旦一个任务不不成功，后面也不需要重复执行if(success)判断逻辑，岂不美哉！