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

客官°小女子只卖身不卖艺 2022-04-25 04:54 149阅读 0赞

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

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