工厂模式：静态工厂

一般认为简单工厂模式，产品部分能够在OCP原则下应对变化（这也恰恰是使用静态工厂的意义所在），但是当新增一种产品时候，我们的工厂的static createProduct还是必须被迫修改代码，也就是不具有应对变化的能力。

本文提供了一种先注册后使用的办法，能够对静态工厂应对变化方面有一定的改善。可能不一定具有太大的使用价值，但对于拓展思路有点启示。

阅读前，先推荐阅读http://www.iteye.com/topic/180972主题：工厂模式----易懂版(转)

Java代码

1. packagecom.eyesmore.staticfactory.spi;
3. importjava.io.ByteArrayInputStream;
4. importjava.io.ByteArrayOutputStream;
5. importjava.io.IOException;
6. importjava.io.ObjectInputStream;
7. importjava.io.ObjectOutputStream;
8. importjava.util.Collections;
9. importjava.util.HashMap;
10. importjava.util.Map;
12. importcom.eyesmore.staticfactory.BenzCar;
14. publicclassCarRegisteryFactory{
16. privatestaticMap<String,Car>registery=Collections.synchronizedMap(newHashMap<String,Car>());
18. publicstaticbooleanregisterCar(Stringname,Carcar){
19. if(registery.containsKey(name))<strong><spanstyle="color:#ff0000;">{//注意：可能导致非线程安全</span>
21. </strong>
24. returnfalse;
25. }
26. registery.put(name,car);
27. returntrue;
28. }
30. publicstaticbooleanunregisterCar(Stringname){
31. if(!registery.containsKey(name)){
32. returnfalse;
33. }
34. registery.remove(name);
35. returntrue;
36. }
38. publicstaticbooleancontainsCar(Stringname){
39. returnregistery.containsKey(name);
40. }
42. publicstaticCarcreateCar(Stringname)throwsNoSuchCarException{
43. if(!registery.containsKey(name)){
44. thrownewNoSuchCarException("CarName="+name);
45. }
46. <strong><spanstyle="background-color:#00ff00;">/*createanewinstanceaccordingtotheregisteredone*/
47. Cartemplate=registery.get(name);
48. returncloneInstance(template);</span>
50. </strong>
53. }
55. /*ExtractMethodfromcreateCar*/
56. privatestaticCarcloneInstance(Cartemplate){
57. CarcloneInstance=null;
58. /*
59. *cloneaninstancebyObjectOutputStream/ObjectInputStream
60. **/
61. try{
62. ByteArrayOutputStreambaos=newByteArrayOutputStream();
63. ObjectOutputStreamoos=newObjectOutputStream(baos);
64. oos.writeObject(template);
65. ObjectInputStreamois=newObjectInputStream(newByteArrayInputStream(baos.toByteArray()));
66. cloneInstance=(Car)ois.readObject();
68. }catch(IOExceptione){//一般只会在调试时发生
69. e.printStackTrace();
70. }catch(ClassNotFoundExceptione){
71. e.printStackTrace();
72. }
73. returncloneInstance;
74. }
78. publicstaticvoidmain(String[]args){
80. CartemplateInstance=newBenzCar();
81. CarRegisteryFactory.registerCar("Benz",templateInstance);
82. Carcar1=CarRegisteryFactory.createCar("Benz");
83. car1.drive();
84. Carcar2=CarRegisteryFactory.createCar("Benz");
85. car2.drive();
86. <strong>System.out.println("(templateInstance==car1)："+(templateInstance==car1));
87. System.out.println("(templateInstance==car2)："+(templateInstance==car2));
88. System.out.println("(car1==car2)："+(car1==car2));//创建的是不同的对象</strong>
91. }
93. }

其他代码：

Java代码

1. packagecom.eyesmore.staticfactory.spi;
3. importjava.io.Serializable;
5. publicinterfaceCarextendsSerializable{//重要对象一般推荐继承Serializable
7. publicvoiddrive();
8. }

Java代码

1. packagecom.eyesmore.staticfactory;
3. importcom.eyesmore.staticfactory.spi.Car;
5. publicclassBenzCarimplementsCar{
7. privatestaticfinallongserialVersionUID=-6849794470754667222L;
9. publicvoiddrive(){
10. System.out.println("Benz...");
11. }
13. }

如果此时要增加Audi，我们的CarRegisterFactory足以应对它。

Java代码

1. packagecom.eyesmore.staticfactory;
3. importcom.eyesmore.staticfactory.spi.Car;
5. publicclassAudiCarimplementsCar{
7. privatestaticfinallongserialVersionUID=-6849794470754667111L;
9. publicvoiddrive(){
10. System.out.println("Audi...");
11. }
13. }

使用时候，先在CarRegisterFactory.registerCar("Audi",new AudiCar());

然后要用的时候则CarRegisterFactory.createCar("Audi");

当然也可以通过配置文件+发射的方式对注册器进行初始化。另外，静态工厂的那个方法的实现有很多种不同的策略，比如log4j的Logger.getLogger，被创建的对象会被重复使用。

==============================================================

【补充】 以上我们通过createInstance()都是重新克隆出一个新的对象实例。当然，很多时候我们并不重新生成新的对象。单例模式我们经常用到Factory.getInstance(); 但是这样导致一个程序只能有一个实例，我们常常需要Factory去维护一个对象名称到对象实例的一个映射关系，典型的就是Log4j，Logger.getLogger(name)。

==============================================================

Factory维护一个name代码

1. //storeinstancesofpools
2. privatestaticMap<String,SockIOPool>pools=
3. newHashMap<String,SockIOPool>();
7. //emptyconstructor
8. protectedSockIOPool(){}
11. /**
12. *Factorytocreate/retrievenewpoolsgivenauniquepoolName.
13. *
14. *@parampoolNameuniquenameofthepool
15. *@returninstanceofSockIOPool
16. */
17. publicstaticsynchronizedSockIOPoolgetInstance(StringpoolName){
18. if(pools.containsKey(poolName))
19. returnpools.get(poolName);
21. SockIOPoolpool=newSockIOPool();
22. pools.put(poolName,pool);
24. returnpool;
25. }
27. /**
28. *Singleargumentversionoffactoryusedforbackcompat.
29. *Simplycreatesapoolnamed"default".
30. *
31. *@returninstanceofSockIOPool
32. */
33. publicstaticSockIOPoolgetInstance(){
34. returngetInstance("default");
35. }

使用静态工厂模式，目的可能不一定是考虑把对象的创建局部在Factory内部，以后修改时只需要修改工厂的代码。从Log4j的例子可以看出使用静态工厂模式还有个好处是方便对象实例的存取，因为如果一个重要对象在很多地方都需要使用，那么作为参数传递还是很不方便的，这常常迫使我们在面向对象时怀念以前过程化程序语言中的全程过程，也就是java的静态方法。