设计模式之不变模式(Immutable Pattern)分析

主要介绍编写不变类的主意事项：

归纳一下设计不变类的 5 条规则：

1． 不提供任何修改对象的方法。

2． 保证没有任何一个方法会被覆盖。

3． 所有的域都是 final 的。

4． 所有的域都是 private 的。

5． 如果不变类内部包括可变的子对象，保证它绝对不会被其他代码获取引用。

 

实例：

/**
* @author Peter Wei
*
*/
public class User {

private String name;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

/**
* 弱不变模式
*
* @author Peter Wei
*
*/
public class WeakImmutable {

// 属性私有，满足条件2
private int state;
// 属性私有，满足条件2
private User user;

private Integer age;

public WeakImmutable(int state, User user, Integer age) {
this.state = state;
this.user = user;
this.age = age;
}

public int getState() {
return this.state;
}

public User getUser() {
return this.user;
}

public Integer getAge() {
return this.age;
}

public void setState() {
// 对象没有任何方法修改对象的状态,满足条件1
// do nothing.
}

public static void main(String[] args) {
int state = 0;
User u = new User();
Integer age = 100;
u.setName("yes");
WeakImmutable weak = new WeakImmutable(state, u, age);
System.out.println("原始值：" + weak.getState() + ","
+ weak.getUser().getName() + "," + weak.getAge());
// 修改引用后
state = 5;
// User由于是可变对象引用，所以有影响
u.setName("no");
age = 200;
System.out.println("修改引用后：" + weak.getState() + ","
+ weak.getUser().getName() + "," + weak.getAge());
}
}结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

我们再引伸一个不可变类的例子:
在时间截止时，我们需要一一检查队列成员是不是vip,如果是可以去USA.假设是多线程环境,并且users数组是多线程共享,那么另外的线程通过users去修改users[n],这时就会把users[n]绕过时间检查而去USA.

Java代码

1. /**
2. * 不变模式之clone
3. *
4. * @author Peter Wei
5. *
6. */
7. publicclass WeakImmutableClone {
9. publicstaticvoid main(String[] args) {
11. User[] users = new User[3];
12. users[0] = new User();
13. users[0].setName("peterwei");
14. users[1] = new User();
15. users[1].setName("Tomssssss");
16. users[2] = new User();
17. users[2].setName("peterwei88");
19. time4Check();
20. /*
21. * 时间到，我们需要一一检查队列成员是不是vip,如果是可以去USA.假设是多线程环境,并且users数组是多线程共享,
22. * 那么另外的线程通过users去修改users[n],这时就会把users[n]绕过时间检查而去USA.
23. */
25. goUSA(users);
27. }
29. publicstaticvoid goUSA(User[] users) {
31. // User[] tmp = new User[users.length];
32. // System.arraycopy(users, 0, tmp, 0, users.length);
34. for (User u : users) {
35. if (checkVip(u)) {
36. System.out.println("You can go!");
37. } else {
38. System.out.println("go away!");
39. }
41. }
42. }
44. publicstaticboolean checkVip(User user) {
45. if (user.getName().startsWith("peterwei")) {
46. returntrue;
47. }
48. returnfalse;
49. }
51. publicstaticvoid time4Check() {
52. // 假设时间期限到，要检查上万人以上的队列。
53. }
54. }

/**
 * 不变模式之clone
 * 
 * @author Peter Wei
 * 
 */
public class WeakImmutableClone {

	public static void main(String[] args) {

		User[] users = new User[3];
		users[0] = new User();
		users[0].setName("peterwei");
		users[1] = new User();
		users[1].setName("Tomssssss");
		users[2] = new User();
		users[2].setName("peterwei88");

		time4Check();
		/*
		 * 时间到，我们需要一一检查队列成员是不是vip,如果是可以去USA.假设是多线程环境,并且users数组是多线程共享,
		 * 那么另外的线程通过users去修改users[n],这时就会把users[n]绕过时间检查而去USA.
		 */

		goUSA(users);

	}

	public static void goUSA(User[] users) {

		// User[] tmp = new User[users.length];
		// System.arraycopy(users, 0, tmp, 0, users.length);

		for (User u : users) {
			if (checkVip(u)) {
				System.out.println("You can go!");
			} else {
				System.out.println("go away!");
			}

		}
	}

	public static boolean checkVip(User user) {
		if (user.getName().startsWith("peterwei")) {
			return true;
		}
		return false;
	}

	public static void time4Check() {
		// 假设时间期限到，要检查上万人以上的队列。
	}
}

解决方法：
在事务处理及数据大批量入库的多线程环境中，应该也会有类似的问题。所以对于这样的传入参数及上例中的不变对象引用可变对象,我们可以将其在相关构造函数及方法中复制为本地变量(数组),及使用它的深度clone,阻止相关数据与外部线程的联系。

Java代码

1. publicstaticvoid goUSA(User[] users) {
3. User[] tmp = new User[users.length];
4. System.arraycopy(users, 0, tmp, 0, users.length);
6. for (User u : tmp) {
7. if (checkVip(u)) {
8. System.out.println("You can go!");
9. } else {
10. System.out.println("go away!");
11. }
13. }
14. }

	public static void goUSA(User[] users) {

		User[] tmp = new User[users.length];
		System.arraycopy(users, 0, tmp, 0, users.length);

		for (User u : tmp) {
			if (checkVip(u)) {
				System.out.println("You can go!");
			} else {
				System.out.println("go away!");
			}

		}
	}

强不变模式：

一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

不变模式在Java中的应用
如String类

Java代码

1. String a = "123" ;
2. String a1 = "123" ;
3. String a2 = "123" ;
4. String a3 = "1234" ;

		String a = "123" ;
		String a1 = "123" ;
		String a2 = "123" ;
		String a3 = "1234" ;

java虚拟机只会创建一个字符串实例，a,a1,a2对象共享一个值。遇到不同的字符串，java虚拟机会再创建一个String对象，如a3。如果程序所处理的字串有频繁的内容变化，就不宜使用String类型，而应当使用StringBuffer类型，如果需要对字串做大量的循环查询，也不宜使用String类型，应当考虑使用byte或char数组.