MonoState模式与SingleTon模式

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

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

   单例的单元测试代码：

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();
		}
	}

}

单例代码

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

MonoState单元测试代码

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());
	}
}

MonoState代码

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还需要多多实践。

评论

2 楼 zhuyufufu 2013-12-20  

dieslrae 写道

我楞是看了半天才发现SingleTon是singleton,咱就不能用大家喜闻乐见的方式来写单词么

感谢提醒，已修正了标题中的单词拼写问题。

1 楼 dieslrae 2013-12-20  

我楞是看了半天才发现SingleTon是singleton,咱就不能用大家喜闻乐见的方式来写单词么