设计模式实例——单例工厂模式

单例模式是平时我们使用比较多的一种模式，在一个系统中，有些对象只能有一个实例，比如windows系统的任务管理器，如果有多个任务管理器的话，那系统就会乱套了。

工厂模式是创建一类对象，将创建和表示分离开，达到解耦。有关这两个模式的详细定义网上有很多，这里就不详述了。

我们将这两个模式结合，用一个工厂去创建系统中的各个单例，这样可以很方便的管理这些单例的生命周期。

首先，我们定义了三个单例类，SingletonC是一个对照类，它的构造方法是public的，我们约定单例类的构造方法必须是private修饰的，所以在工厂中不能创建SingletonC的单例。

public class SingletonA {

    private SingletonA(){}

    public void method() {
        System.out.println("I am Singleton-A");
    }
}

public class SingletonB {

    private SingletonB(){}

    public void method() {
        System.out.println("I am Singleton-B");
    }
}

public class SingletonC {
    public void method() {
        System.out.println("I am Singleton-C");
    }
}

接下来是定义工厂类，这用反射的方式去创建这些单例，代码很简单也都有注释。

public class SingletonFactory {
    //一个Map对象，用来存储已经创建的单例对象的实例
    private static Map<Class, Object> singletons = new HashMap<Class, Object>();

    public static synchronized <T> T getSingleton(Class<T> t) {
        //先从Map里获取以t为键的实例
        Object o = singletons.get(t);
        if(o == null) {
            //如果Map里不存在该类的实例则利用反射新建一个
            try {
                Constructor constructor = t.getDeclaredConstructor();
                
                //如果该类的构造函数不是private则抛出异常
                if(constructor.getModifiers() != Modifier.PRIVATE) {
                    throw new Exception("Singleton class constructor must be private");
                }
                constructor.setAccessible(true);
                
                //创建实例，并放入Map中
                o = constructor.newInstance();
                singletons.put(t, o);
                return (T) o;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        } else {
            return (T) o;
        }
    }
}

根据传入的Class类型去创建相应的实例，并返回该实例，这里用了泛型。

下来是一个客户类，

public class Client {
    public static void main(String[] args) {
        SingletonA singletonA =  SingletonFactory.getSingleton(SingletonA.class);
        singletonA.method();
        SingletonA singletonA1 = SingletonFactory.getSingleton(SingletonA.class);
        singletonA1.method();
        System.out.println(singletonA + "," + singletonA1);

        SingletonB singletonB =  SingletonFactory.getSingleton(SingletonB.class);
        singletonB.method();
        SingletonB singletonB1 = SingletonFactory.getSingleton(SingletonB.class);
        singletonB1.method();
        System.out.println(singletonB + "," + singletonB1);

        SingletonC singletonC = SingletonFactory.getSingleton(SingletonC.class);
    }
}

运行结果：

从结果我们可以看出，每个单例类只创建了一个实例，客户端获取的都是同一个对象。SingletonC因为它的构造方法是public的所以抛出的异常。

这就是今天和大家分享的一个很简单的模式。