研磨设计模式笔记之简单工厂模式

1.不用模式的解决方案

1.1 示例

(1)首先定义接口Api,示例代码如下：

public interface Api {
    public void test1(String s);
}

(2)有了Api，自然要有实现，此处功能为输出字符串，示例如下：

public class ImplA implements  Api{
    @Override
    public void test1(String s) {
        System.out.println("Now In Impl. The input s == " + s);
    }
}

(3)客户端调用实现

public class Client {
    public static void main(String[] args){
        Api api = new ImplA();
        api.test1("哈哈，不要紧张，只是一个测试而已！");
    }
}

1.2 分析问题

可以看到上例中，客户端已经知道了相应的实现，所以根本没有做到“封装隔离”。
要做到“封装隔离”，客户端就不应该知道具体的实现是什么，那么“new Impl()”就应该封装起来，让客户端看不到。

2.带模式的解决方案

2.1 简单工厂重写示例

（1）Api与相应实现Impl都与上面相同
此处主要说一下简单工厂Factory，示例如下：

public class Factory {
	//返回的实例包裹在Factory中，这样客户端就看不到了
    public static Api create(){
        return new ImplA();
    }
}

（2）重写客户端代码，代码如下：

public class Client {
    public static void main(String[] args){
    	//这个时候就不用显式写出new Impl()，而是通过工厂来返回
        Api api = Factory.create();
        api.test1("正在测试重写简单工厂。。。");
    }
}

从客户端来看，不需要知道具体的实现是什么，也不需要知道如何实现的，只知道从工厂获得了一个接口对象，然后通过接口来获取想要的功能。

2.2 带选择的简单工厂

上面重写示例中，只有一种实现，要是有多种实现又该如何呢？
（1）Api和相应实现不变
在上面的基础上再添加一种实现ImplB,代码如下：

public class ImplB implements Api {
    @Override
    public void operation(String s) {
        System.out.println("ImplB s == "+ s);
    }
}

(2)修改简单工厂Factory,做到选择实现，代码如下：

public class Factory {
    public static Api create(int condition){
        Api api = null;
        if(condition == 1){
            api = new ImplA();
        }else if(condition == 2){
            api = new ImplB();
        }
        return api;
    }
}

(3)修改客户端代码：

public class Client {
    public static void main(String[] args){
    //客户端通过1或者2,来选择相应的实现
        Api api = Factory.create(1);
        api.operation("正在使用简单工厂");
    }
}

2.3 带选择的简单工厂的缺陷

带选择的简单工厂有很大的局限性，如果有多重选择，那么就要在工厂中多次判断，复杂性大大提升。另外从客户端调用工厂的时候传入选择的参数，增加了硬编码。
这种复杂性不能放在代码中来判断，而应该放在外部，从代码中独立出来，放在配置中。

2.4 可配置的简单工厂

(1)配置文件用properties文件，定义一个“FactoryTest.properties”文件放在工厂类的同一个包下，内容如下：

ImplClass=com.zte.rewriteonproperties.ImplA

(2)修改工厂类Factory,代码如下：

public class Factory {
    
    public static Api createApi(){
    	Properties p = new Properties();
    	InputStream in = null;
    	//读取配置文件
        in = Factory.class.getResourceAsStream("FactoryTest.properties");
        try {
            p.load(in);
        } catch (IOException e) {
            System.out.println("装载工厂配置文件出错了，具体的堆栈信息如下：");
            e.printStackTrace();
        }finally {
            try {
            //读取完毕，要记住关流
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Api api = null;
        try {
            try {
            //反射创建实例
                api =(Api)Class.forName(p.getProperty("ImplClass")).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return api;
    }
}

（3）客户端代码示例如下：

public class Client {
    public static void main(String[] args){
    //可以看到，此时就不需要传入参数，复杂性直接转移到配置文件中控制
        Api api = Factory.createApi();
        api.test1("哈哈哈，不要紧张，测试而已！");
    }
}

3.思考简单工厂

本人还处于学习阶段，在使用简单工厂方面还缺少经验。
根据我的理解，在同一个功能有多重实现的时候，就可以选用简单工厂，一方面能够做到接口隔离，另一方面能够做到选择实现，集中管理和控制。
举个例子，同样的打印功能，可以用爱普生的，或者惠普的。这些打印厂家都实现了打印标准，同一接口。
(1)首先有个同一的接口Print

public interface Print{
	public void print(String s);
}

(2)然后再有多个实现EpsonImpl,HpImpl

public class EpsonImpl implements Print{
	public void print(String s){
		System.out.println("this is EpsonPrinter");
	}
}

public class HpImpl implements Print{
	public void print(String s){
		System.out.println("this is EpsonPrinter");
	}
}

再之后就可以从多个实现中做出选择，完成打印功能的隔离。