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

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");
	}
}

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

你可能感兴趣的:(Design,Patterns)