[b]SigleTon模式[/b]可能是最为软件从业人员所知的一种模式了。但是与其有异曲同工之妙的[b]MonoState模式[/b]则不那么流行了。
在介绍MonoState之前先说一下SingleTon。SingleTon在静态存储区存储了自己的一个实例,这个实例持有业务需要的内容(也就是实例的属性)。通过对构造器的私有化,以及对克隆的限制达到控制单例实例数为一的目的。扩展开来SigleTon不仅可以控制单例实例数为一,也可以控制实例数为二、为三直至n,也就是说可以控制实例数为固定数目。
[b]单例的单元测试代码:[/b]
[b]单例代码[/b]
MonoState从另外一个角度实现了内容控制,也就是讲类的属性全部放到静态存储区,这样所有的类实例都共享了属性。每个实例的属性在改变的同时也改变了别的实例的属性。
[b]MonoState单元测试代码[/b]
[b]MonoState代码[/b]
Monostate模式的关键就在于类属性的全局共享化。从这个模式也可以看出设计模式是对简单编程思想的合理运用。
具体的工作场景中怎么运用MonoState还需要多多实践。
在介绍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还需要多多实践。