单例模式完全剖析(3)---- 探究简单却又使人迷惑的单例模式

使用注册表

使用一个单例类注册表可以：

在运行期指定单例类

防止产生多个单例类子类的实例
在例8的单例类中，保持了一个通过类名进行注册的单例类注册表：
例8带注册表的单例类

1. importjava.util.HashMap;
2. importorg.apache.log4j.Logger;
4. publicclassSingleton{
5. privatestaticHashMapmap=newHashMap();
6. privatestaticLoggerlogger=Logger.getRootLogger();
8. protectedSingleton(){
9. //Existsonlytothwartinstantiation
10. }
11. publicstaticsynchronizedSingletongetInstance(Stringclassname){
12. if(classname==null)thrownewIllegalArgumentException("Illegalclassname");
13. Singletonsingleton=(Singleton)map.get(classname);
15. if(singleton!=null){
16. logger.info("gotsingletonfrommap:"+singleton);
17. returnsingleton;
18. }
19. if(classname.equals("SingeltonSubclass_One"))
20. singleton=newSingletonSubclass_One();
21. elseif(classname.equals("SingeltonSubclass_Two"))
22. singleton=newSingletonSubclass_Two();
24. map.put(classname,singleton);
25. logger.info("createdsingleton:"+singleton);
26. returnsingleton;
27. }
28. //Assumefunctionalityfollowsthat'sattractivetoinherit
29. }

这段代码的基类首先创建出子类的实例，然后把它们存储在一个Map中。但是基类却得付出很高的代价因为你必须为每一个子类替换它的getInstance()方法。幸运的是我们可以使用反射处理这个问题。

使用反射

在例9的带注册表的单例类中，使用反射来实例化一个特殊的类的对象。与例8相对的是通过这种实现，Singleton.getInstance()方法不需要在每个被实现的子类中重写了。
例9使用反射实例化单例类

1. importjava.util.HashMap;
2. importorg.apache.log4j.Logger;
4. publicclassSingleton{
5. privatestaticHashMapmap=newHashMap();
6. privatestaticLoggerlogger=Logger.getRootLogger();
8. protectedSingleton(){
9. //Existsonlytothwartinstantiation
10. }
11. publicstaticsynchronizedSingletongetInstance(Stringclassname){
12. Singletonsingleton=(Singleton)map.get(classname);
14. if(singleton!=null){
15. logger.info("gotsingletonfrommap:"+singleton);
16. returnsingleton;
17. }
18. try{
19. singleton=(Singleton)Class.forName(classname).newInstance();
20. }
21. catch(ClassNotFoundExceptioncnf){
22. logger.fatal("Couldn'tfindclass"+classname);
23. }
24. catch(InstantiationExceptionie){
25. logger.fatal("Couldn'tinstantiateanobjectoftype"+classname);
26. }
27. catch(IllegalAccessExceptionia){
28. logger.fatal("Couldn'taccessclass"+classname);
29. }
30. map.put(classname,singleton);
31. logger.info("createdsingleton:"+singleton);
33. returnsingleton;
34. }
35. }

关于单例类的注册表应该说明的是：它们应该被封装在它们自己的类中以便最大限度的进行复用。

封装注册表

例10列出了一个单例注册表类。
例10一个SingletonRegistry类

1. importjava.util.HashMap;
2. importorg.apache.log4j.Logger;
4. publicclassSingletonRegistry{
5. publicstaticSingletonRegistryREGISTRY=newSingletonRegistry();
7. privatestaticHashMapmap=newHashMap();
8. privatestaticLoggerlogger=Logger.getRootLogger();
10. protectedSingletonRegistry(){
11. //Existstodefeatinstantiation
12. }
13. publicstaticsynchronizedObjectgetInstance(Stringclassname){
14. Objectsingleton=map.get(classname);
16. if(singleton!=null){
17. returnsingleton;
18. }
19. try{
20. singleton=Class.forName(classname).newInstance();
21. logger.info("createdsingleton:"+singleton);
22. }
23. catch(ClassNotFoundExceptioncnf){
24. logger.fatal("Couldn'tfindclass"+classname);
25. }
26. catch(InstantiationExceptionie){
27. logger.fatal("Couldn'tinstantiateanobjectoftype"+
28. classname);
29. }
30. catch(IllegalAccessExceptionia){
31. logger.fatal("Couldn'taccessclass"+classname);
32. }
33. map.put(classname,singleton);
34. returnsingleton;
35. }
36. }

注意我是把SingletonRegistry类作为一个单例模式实现的。我也通用化了这个注册表以便它能存储和取回任何类型的对象。例11显示了的Singleton类使用了这个注册表。
例11使用了一个封装的注册表的Singleton类

1. importjava.util.HashMap;
2. importorg.apache.log4j.Logger;
4. publicclassSingleton{
6. protectedSingleton(){
7. //Existsonlytothwartinstantiation.
8. }
9. publicstaticSingletongetInstance(){
10. return(Singleton)SingletonRegistry.REGISTRY.getInstance(classname);
11. }
12. }

上面的Singleton类使用那个注册表的唯一实例通过类名取得单例对象。
现在我们已经知道如何实现线程安全的单例类和如何使用一个注册表去在运行期指定单例类名，接着让我们考查一下如何安排类载入器和处理序列化。

Classloaders

在许多情况下，使用多个类载入器是很普通的--包括servlet容器--所以不管你在实现你的单例类时是多么小心你都最终可以得到多个单例类的实例。如果你想要确保你的单例类只被同一个的类载入器装入，那你就必须自己指定这个类载入器;例如：

1. privatestaticClassgetClass(Stringclassname)
2. throwsClassNotFoundException{
3. ClassLoaderclassLoader=Thread.currentThread().getContextClassLoader();
5. if(classLoader==null)
6. classLoader=Singleton.class.getClassLoader();
8. return(classLoader.loadClass(classname));
9. }
10. }

这个方法会尝试把当前的线程与那个类载入器相关联;如果classloader为null，这个方法会使用与装入单例类基类的那个类载入器。这个方法可以用Class.forName()代替。

序列化

如果你序列化一个单例类，然后两次重构它，那么你就会得到那个单例类的两个实例，除非你实现readResolve()方法，像下面这样：
例12一个可序列化的单例类

1. importorg.apache.log4j.Logger;
3. publicclassSingletonimplementsjava.io.Serializable{
4. publicstaticSingletonINSTANCE=newSingleton();
6. protectedSingleton(){
7. //Existsonlytothwartinstantiation.
8. }
9. [b]privateObjectreadResolve(){
10. returnINSTANCE;
11. }[/b]}

上面的单例类实现从readResolve()方法中返回一个唯一的实例;这样无论Singleton类何时被重构，它都只会返回那个相同的单例类实例。
例13测试了例12的单例类：
例13测试一个可序列化的单例类

1. importjava.io.*;
2. importorg.apache.log4j.Logger;
3. importjunit.framework.Assert;
4. importjunit.framework.TestCase;
6. publicclassSingletonTestextendsTestCase{
7. privateSingletonsone=null,stwo=null;
8. privatestaticLoggerlogger=Logger.getRootLogger();
10. publicSingletonTest(Stringname){
11. super(name);
12. }
13. publicvoidsetUp(){
14. sone=Singleton.INSTANCE;
15. stwo=Singleton.INSTANCE;
16. }
17. publicvoidtestSerialize(){
18. logger.info("testingsingletonserialization...");
19. [b]writeSingleton();
20. Singletons1=readSingleton();
21. Singletons2=readSingleton();
22. Assert.assertEquals(true,s1==s2);[/b]}
23. privatevoidwriteSingleton(){
24. try{
25. FileOutputStreamfos=newFileOutputStream("serializedSingleton");
26. ObjectOutputStreamoos=newObjectOutputStream(fos);
27. Singletons=Singleton.INSTANCE;
29. oos.writeObject(Singleton.INSTANCE);
30. oos.flush();
31. }
32. catch(NotSerializableExceptionse){
33. logger.fatal("NotSerializableException:"+se.getMessage());
34. }
35. catch(IOExceptioniox){
36. logger.fatal("IOException:"+iox.getMessage());
37. }
38. }
39. privateSingletonreadSingleton(){
40. Singletons=null;
42. try{
43. FileInputStreamfis=newFileInputStream("serializedSingleton");
44. ObjectInputStreamois=newObjectInputStream(fis);
45. s=(Singleton)ois.readObject();
46. }
47. catch(ClassNotFoundExceptioncnf){
48. logger.fatal("ClassNotFoundException:"+cnf.getMessage());
49. }
50. catch(NotSerializableExceptionse){
51. logger.fatal("NotSerializableException:"+se.getMessage());
52. }
53. catch(IOExceptioniox){
54. logger.fatal("IOException:"+iox.getMessage());
55. }
56. returns;
57. }
58. publicvoidtestUnique(){
59. logger.info("testingsingletonuniqueness...");
60. Singletonanother=newSingleton();
62. logger.info("checkingsingletonsforequality");
63. Assert.assertEquals(true,sone==stwo);
64. }
65. }

前面这个测试案例序列化例12中的单例类，并且两次重构它。然后这个测试案例检查看是否被重构的单例类实例是同一个对象。下面是测试案例的输出：

2. Buildfile:build.xml
4. init:
5. [echo]Build20030422(22-04-200311:32)
7. compile:
9. run-test-text:
10. [java].INFOmain:testingsingletonserialization...
11. [java].INFOmain:testingsingletonuniqueness...
12. [java]INFOmain:checkingsingletonsforequality
14. [java]Time:0.1
16. [java]OK(2tests)

单例模式结束语

单例模式简单却容易让人迷惑，特别是对于Java的开发者来说。在这篇文章中，作者演示了Java开发者在顾及多线程、类载入器和序列化情况如何实现单例模式。作者也展示了你怎样才能实现一个单例类的注册表，以便能够在运行期指定单例类。