引言

一般来说，随着我们项目的迭代以及业务的越来越复杂，项目中的分支判断会原来越多。当项目中涉及到复杂的业务判断或者分支逻辑时，我们就需要考虑是否需要对项目进行重构了，或者if else和switch case是否能够满足当前项目的复杂度。

我们举一个简单的例子，假如我们是马戏团的老板，在训练一些动物去做一些指令，刚开始很简单，只训练了一条狗，当狗握了一下手后，给她奖励一些狗粮。这样慢慢地小狗就学会了握手。

我们先定义一条小狗对象，小狗做了某些事情(“握手”)后，可以得到一些奖励

public class Dog {
 	public void train(){
 		System.out.println("握手");
 	}
 	public void getReward(){
 		System.out.println("狗粮");
 	}
 }

定义驯兽师，通过train来训练动物

public class Beast {
	/**
	 * 训练
	 */
	public void train(Dog dog){
		/**
		 * 狗狗做了一些事情
		 */
		dog.train();
		/**
		 * 狗狗得到奖励
		 */
		dog.getReward();
	}
}

如果我们只需要训练一条动物，那么相对来说比较简单。但是后来马戏团又引进了一头狮子，需要训练狮子钻火圈，因此，为了区分狗和狮子，我们增加了一种类型区分训练的动物是狗还是狮子。

public class Lion {
	public void doSomething(){
		System.out.println("钻火圈");
	}
	public void getReward(){
		System.out.println("得到一只鸡");
	}
}

重新修改Beast类，使其既可以训练小狗，又可以训练狮子

public class Beast {

	public void train(Object animal, int type){
		if (type == 1){
			trainDog((Dog)animal);
		}else if (type == 2){
			trainLion((Lion)animal);
		}
	}

	/**
	 * 训练
	 */
	public void trainDog(Dog dog){
		/**
		 * 狗狗做了一些事情
		 */
		dog.doSomething();
		/**
		 * 狗狗得到奖励
		 */
		dog.getReward();
	}
	/**
	 * 训练
	 */
	public void trainLion(Lion lion){
		/**
		 * 狗狗做了一些事情
		 */
		lion.doSomething();
		/**
		 * 狗狗得到奖励
		 */
		lion.getReward();
	}
}

我们通过type类型来区分训练的动物类型，后来马戏团引来了越来越多的动物，那我们的type的取值会越来越多：1表示狗，2表示狮子，3表示猫，4表示老虎，5表示猴子...等等。而且随着系统越来越复杂，我们在训练之前不同的动物还需要做不同的准备工作。当然，目前的系统只要增加if else或者switch case是可以满足需求的，但这样写显得不是太优雅，我们希望找到一种比较优雅比较有设计感的方式来取代if else或者switch case

优化if else

在做优化之前，我们需要先弄清楚我们的目的。我们是马戏团的驯兽师，目的是训练动物。

- 目的：训练动物做一些事情(train)

- 方式：通过奖励(getReward)诱导动物进行训练。

有了上面的目的之后，我们就可以定义一个模型animal

public interface IAnimal {

	/**
	 * 获取动物种类
	 * @return
	 */
	int getType();

	/**
	 * 训练动作
	 */
	void train();
}

Animal只暴露两个方法，其中doSomething是专门用来训练动物的，至于如何训练全都由子类实现。

- getType():用来区分不同的动物

- train():训练动物

然后我们定义一个子类实现这个接口，用来具体化如何训练动物

public abstract class AbsTrainAnimal implements IAnimal{

	/**
	 * 训练前需要做的准备
	 */
	abstract void beforeTrain();

	/**
	 * 训练后需要做的准备
	 */
	abstract void afterTrain();

	/**
	 * 训练出现异常需要做的
	 */
	abstract void exceptionTrain(Throwable throwable);

	/**
	 * 具体训练
	 */
	abstract void doSomething();

	/**
	 * 训练动作
	 */
	@Override
	public final void train() {
		try {
			beforeTrain();
			doSomething();
			afterTrain();
		}catch (Throwable throwable){
			exceptionTrain(throwable);
		}
	}
}

我们定义了一个抽象类用来实现IAnimal接口，作为所有动物训练的基类。其中实现的接口train使用了final进行了限制，防止子类对其进行覆盖操作。

在AbsTrainAnimal中，我们对train()进行了各种功能的细化

- doSomething：具体训练的内容

- beforeTrain：训练之前需要做的一些准备

- afterTrain：训练之后需要做的事情

- exceptionTrain：训练中发生意外应该如何处理

因为所有动物的以上四个方法可能都不相同，所以我们声明为abstract方法，方便子类自己实现。基于以上设计，我们就可以定义一个Dog类，对其进行训练。

public class Dog extends AbsTrainAnimal {
	/**
	 * 训练前需要做的准备
	 */
	@Override
	void beforeTrain() {
		System.out.println("抚摸额头以示鼓励");
	}

	/**
	 * 训练后需要做的准备
	 */
	@Override
	void afterTrain() {
		System.out.println("奖励一些狗粮");
	}

	/**
	 * 训练出现异常需要做的
	 *
	 * @param throwable
	 */
	@Override
	void exceptionTrain(Throwable throwable) {
		System.out.println("出去罚站");
	}

	/**
	 * 具体训练
	 */
	@Override
	void doSomething() {
		System.out.println("握手");
	}

	/**
	 * 获取动物种类
	 *
	 * @return
	 */
	@Override
	public int getType() {
		return 1;
	}
}

我们再定义一个Lion

public class Lion extends AbsTrainAnimal {
	/**
	 * 训练前需要做的准备
	 */
	@Override
	void beforeTrain() {
		System.out.println("友好交流");
	}

	/**
	 * 训练后需要做的准备
	 */
	@Override
	void afterTrain() {
		System.out.println("奖励一只鸡");
	}

	/**
	 * 训练出现异常需要做的
	 *
	 * @param throwable
	 */
	@Override
	void exceptionTrain(Throwable throwable) {
		System.out.println("紧急送往医院");
	}

	/**
	 * 具体训练
	 */
	@Override
	void doSomething() {
		System.out.println("钻火圈");
	}

	/**
	 * 获取动物种类
	 *
	 * @return
	 */
	@Override
	public int getType() {
		return 2;
	}
}

我们可以看到，Dog和Lion的动物种类是不一样的，Dog为1，Lion为2。我们可以根据type区分是狮子还是狗。但为了避免使用if else进行区分，我们需要一个工厂类来生产这两种动物。

@Service
public class AnimalFactory {

	private static List> animalLists = Lists.newArrayList();
	private static Map animalMaps = Maps.newHashMap();

	static {
		animalLists.add(Dog.class);
		animalLists.add(Lion.class);
	}

	@PostConstruct
	public void init() throws IllegalAccessException, InstantiationException {
		for (Class clazz : animalLists){
			Object obj = clazz.newInstance();
			animalMaps.put(obj.getType(), obj);
		}
	}

	/**
	 * 构建动物类
	 * @param type
	 * @return
	 */
	IAnimal build(int type){
		return animalMaps.get(type);
	}
}

我们有了这个工厂类，就可以根据不同的动物类型获取不同的对象，并对其进行训练。当然我们这里都是使用的单例模式，每个对象只对应一个实例，如果每次都生成不同的实例，可以对其进行简单的改造即可实现。

我们再重写驯兽师Beast类

@Service
public class Beast {

	@Resource
	private AnimalFactory animalFactory;

	/**
	 * 训练动物，只需要知道动物的类型即可
	 * @param type
	 */
	public void train(int type){
		IAnimal animal = animalFactory.build(type);
		animal.train();
	}
}

可以看到train方法只需要关系动物类型即可，不需要再根据type进行判断动物类型在对其进行不同的操作。如果有新的动物加入，只需要实现AbsTrainAnimal基类，然后向AnimalFactory进行注册即可。避免了根据不同type进行if else或者switch的判断

总结

其实，上述所述的方法不但但省去了if else的判断，也是目前比较流行的领域模型的一种实现方式。IAnimal是领域内对外暴露的唯一方式，外部领域(驯兽师)不需要关心任何内部实现的细节。内部的实现完全集合在IAnimal内。