单例模式

单例模式属于创建性模式,目的是保证一个类仅有一个实例,并提供一个它的全局

访问点。常用于一些工厂的创建，管理器对象的创建，或者全局注册表。
一、它的普通实现为：

public class Singleton {

	private static Singleton singleton;

	public synchronized static Singleton getSingletonInstance() {
		if (singleton == null) {
			singleton = new Singleton();
		}
		return singleton;
	}

	private Singleton() {
	}

	public void say() {
		System.out.println("我要开始说话了.......");
	}
}

如果说创建的是一个工厂，我们可以在工厂中对产品进行生产时，就可以保证当

前只有一个工厂。

public class Factory {

	private static Factory factory;
        //保证工厂创建一次，并且线程安全
	public synchronized static Factory getFactoryInstance() {
		if (factory == null) {
			factory = new Factory();
		}
		return factory;
	}
       //允许子类实例化
	protected Factory() {
	}
        //创建一个Product产品
	public Product getAppleInstance() {
		return new Apple() ;
	}
}

Product是一个接口，Apple是它的一个实现类
客户代码：
Product apple = Factory.getFactoryInstance().getAppleInstance() ;


二、使用单例注册表
1、创建一个产品接口与它生产的产品

package com.hejianjiao.single.register;

public interface BeanFactory {
	public void getBean();
}

class AppleBean implements BeanFactory {
	public void getBean() {
		System.out.println("生产一个苹果....");
	}
}

class OrangeBean implements BeanFactory {
	public void getBean() {
		System.out.println("生产一个橘子....");
	}
}

2、使用一个单例注册表

package com.hejianjiao.single.register;

import java.util.HashMap;
import java.util.Map;

public class FactorySingletonRegister {

	private static FactorySingletonRegister instance;
	private static Map<String, BeanFactory> factorySingle = new HashMap();

	private FactorySingletonRegister() {
	}

	// 获取一个单例工厂
	public synchronized static FactorySingletonRegister getInstance() {
		if (instance == null)
			instance = new FactorySingletonRegister();
		return instance;
	}

	public synchronized static BeanFactory getBean(String className) {
		// 从集合中取得一个BeanFactory的类的实例
		BeanFactory factory = (BeanFactory) factorySingle.get(className);
		if (factory != null)
			return factory;
		// 没有取到实例时,就使用反射创建一个实例
		try {
			factory = (BeanFactory) Class.forName(className).newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		// 创建完实例后,再放入集合对象中
		factorySingle.put(className, factory);
		return factory;
	}
}

3、客户端测试

package com.hejianjiao.single.register;

public class Test {

	public static void main(String[] args) {
		// 创建一个注册表,保证工厂的单一性
		FactorySingletonRegister registery = FactorySingletonRegister
				.getInstance();
		// 使用反射机制传入class名
		BeanFactory appleBean = registery
				.getBean("com.hejianjiao.single.register.AppleBean");
		BeanFactory orangeBean = registery
				.getBean("com.hejianjiao.single.register.OrangeBean");
		appleBean.getBean();
		orangeBean.getBean();
	}

}

以上代码也可以是这样的简单,但这时,就没有用到它的单例性了.
public class Test {

	public static void main(String[] args) {

		// 使用反射机制传入class名
		FactorySingletonRegister.getBean(
				"com.hejianjiao.single.register.AppleBean").getBean();
		FactorySingletonRegister.getBean(
				"com.hejianjiao.single.register.OrangeBean").getBean();
		}

}

在本例中，工厂方法依赖于一个参数标识来决定产品的具体生产形为，这就可以

说是一个参数化工厂方法，这种方法的好处是，我创建好了以后，就不需要再对

工厂进行修改了，只需要扩展产品类，然后在客户端向工厂传送一个类的地址就

可以生产了。这种方式就相当于，我只需要给工厂一个任何产品的说明书，它就

可以给我生产出来这种产品了。使工厂的生产力放到最大。
本例中还用到了反射和工厂方法模式的一些结合，使工厂生产力扩大。