MonoState模式与SingleTon模式

[b]SigleTon模式[/b]可能是最为软件从业人员所知的一种模式了。但是与其有异曲同工之妙的[b]MonoState模式[/b]则不那么流行了。

在介绍MonoState之前先说一下SingleTon。SingleTon在静态存储区存储了自己的一个实例，这个实例持有业务需要的内容（也就是实例的属性）。通过对构造器的私有化，以及对克隆的限制达到控制单例实例数为一的目的。扩展开来SigleTon不仅可以控制单例实例数为一，也可以控制实例数为二、为三直至n，也就是说可以控制实例数为固定数目。

[b]单例的单元测试代码：[/b]

package com.zas.pattern.test;

import static org.junit.Assert.*;

import java.lang.reflect.Constructor;

import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import com.zas.pattern.SingleTon;

/**
 * 单例模式测试
 * @author zas
 *
 */
public class SingleTonTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public void testNewInstance() {
		SingleTon s = SingleTon.newInstance();
		SingleTon s2 = SingleTon.newInstance();
		assertSame(s, s2);
	}

	@Test
	public void testNoConstructor() {
		try {
			Class<?> singleTonClass = Class.forName("com.zas.pattern.SingleTon");
			Constructor<?>[] construtors = singleTonClass.getConstructors();
			assertEquals("没有公共构造器", 0, construtors.length);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testNoClone() {
		SingleTon s = SingleTon.newInstance();
		try {
			Object obj = s.clone();
			if(obj instanceof CloneNotSupportedException){
				assertTrue(true);
			}else{
				fail();
			}
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}

}

[b]单例代码[/b]

package com.zas.pattern;

/**
 * 单例模式
 * @author zas
 */
public class SingleTon {

	//静态存储区存储的是单例的类
	private static SingleTon singleTon;

	//单例内容的内容
	private String content;

	private SingleTon() {
		content = "初始化单例类内容";
	}

	public static SingleTon newInstance() {
		if(null == singleTon){
			singleTon = new SingleTon();
		}
		return singleTon;
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
		return new CloneNotSupportedException();
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {

	}

}

MonoState从另外一个角度实现了内容控制，也就是讲类的属性全部放到静态存储区，这样所有的类实例都共享了属性。每个实例的属性在改变的同时也改变了别的实例的属性。

[b]MonoState单元测试代码[/b]

package com.zas.pattern;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class MonoStateTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public void test() {
		MonoState monoState = new MonoState();
		assertEquals("初始化单例类内容", monoState.getContent());
	}

	@Test
	public void testInstances() {
		MonoState monoState = new MonoState();
		MonoState monoState2 = new MonoState();
		assertEquals(monoState.getContent(), monoState2.getContent());
		monoState.setContent("改变了实例内容");
		assertEquals(monoState.getContent(), monoState2.getContent());
	}
}

[b]MonoState代码[/b]

package com.zas.pattern;

/**
 * MonoState 模式
 * @author zas
 */
public class MonoState {
	//类持有的内容
	private static String content = "初始化单例类内容";

	public MonoState() {

	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		MonoState.content = content;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return new CloneNotSupportedException();
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {

	}

}

Monostate模式的关键就在于类属性的全局共享化。从这个模式也可以看出设计模式是对简单编程思想的合理运用。

具体的工作场景中怎么运用MonoState还需要多多实践。