Registry of Singleton 模式

不知道大家平时有没有遇到大量使用单例类的情况，当我们的项目变得庞大，人员分组变的复杂，出现各种分支，简单易用的单例类使用就会泛滥。

这里总结下项目中遇到并使用的方法，基本思路都是 Registry of Singleton 模式，将单例类使用数据结构保存起来，通过Key Value 一一对应。

1、Reflection 机制

public class SingletonRegistry {
    private static Map<String, Object> registry = new HashMap<String, Object>();

    private SingletonRegistry() {}

    public static Object getInstance(String classname) {
        Object singleton = registry.get(classname);

        if(singleton != null) {
            return singleton;
        }
        try {
            singleton = Class.forName(classname).newInstance();
        }
        catch(Exception e) {
            throw new RuntimeException(e);
        }

        registry.put(classname, singleton);

        return singleton;
    }

2、Registry 机制

public class SingletonRegistry {
    private static Map<String, Object> registry = new HashMap<String, Object>();
    private static Singleton instance;

    private SingletonRegistry() {}

    public static void register(String name, Object singleton) {
        registry.put(name, singleton);
    }

    public static Object getInstance(String classname) {
        return registry.get(classname);
    }

以上两种方式是最简单通用的方式，但是使用object作为参数难免会觉得无法控制无法感知，所就利用以上思想就有了现在的方式。

3、接口包装

• 基本思路同上，注册方式来保证 key value 一一对应
• 面向接口
• 对每一个对应的单例类接口自行处理 object 转化类型，也就是转成当前的类型
• 封装 key 对应的工具类，统一入口获取单例类

public class SingletonManager {
     private static SingletonManager mInstance = new SingletonManager();

     private final Map<String, ISingletonWrapper> mMap = new HashMap<String, ISingletonWrapper>();

     private SingletonManager() {
}

     public static SingletonManager get() {
          return mInstance;
}

     public void register(String key, ISingletonWrapper ifWrapper) {
          mMap.put(key, ifWrapper);
}

     public void unRegister(String key) {
          mMap.remove(key);
}

     public ISingletonWrapper get(String key) {
          return mMap.get(key);
}
}

ISingletonWrapper 是个接口 只有一个方法，返回 object

public interface ISingletonWrapper {
    Object getInterface();
}

剩余就是自由发挥了，对 object 做一个封装，让外界感知都是接口就OK了

其余就是对这部分使用的扩展，本组大神压阵，代码就不贴了

大致提供下思路：

比如单例类接口为 ITextProvider，将 ITextProvider 继承 ISingletonWrapper 接口，同时声明一个内部类实现 ITextProvider，构造一个静态方法将 object 和 ITextProvider 做强转匹配即可，外层工具类随便写就行了，只能到这了。。

提高

考虑一种场景:一个host有两个依赖的库，并且这两个库是同级且相互不依赖，如果这时候想在Library1 中调用 Library2 的方法，该怎么做？

我这里不考虑一些特殊或者侵入式方法，使用接口来简单实现，抽象出一个公共接口，放入 share中，是 Library1 和 Library2 都作为依赖，在 host起来的时候，实例化 Library1 中的接口实现类，同时set 到 Library2 中，完毕…

参考

• Registry of Singleton 模式