java代理模式的学习(动态代理+静态代理)

作者:rui1187349730
一、为什么要使用代理模式
为了为某些类的方法附加上额外且通用的功能,同时不改变原来的代码结构。eg:为操作数据库的代码加上事务(使用spring的aop)

二、代理模式的角色
1、抽象角色:是下面的真实角色和代理角色的公有方法的集合。一般为接口,也可以是抽象方法
2、真实角色:是拥有核心功能的类
3、代理角色:拥有真实角色的引用,同时附加了额外的功能。
eg:租房子这件事里面,有中介,房主,和租房者,这里的租房者就是客户端,中介是代理角色,房主就是真实角色。租房者要租房,但是他是通过中介这个代理去完成租房
(核心功能)这件事的,但是同时他能够帮客户与房主联系,讨价还价等等(附加功能)。但是最终还是房主把房子租给了客户(完成核心功能的最终还是真实角色)。

三、三者之间的关系
1、真实角色和代理角色要实现抽象角色定义的公有方法
2、代理角色拥有真实角色的引用

四、静态代理
首先看实现吧
1、抽象角色

1
2
3
4
5
6
7
8
9
10


/**
* 代理模式中的公有接口(起到统一的作用)
* */
public interface Subject {

public void request();

}

2、真实角色

1
2
3
4
5
6
7
8
9
10
11
12
13
14


/**
* 代理模式里面的真实角色
* */
public class RealSubject implements Subject{

@Override
public void request() {
System.out.println("this is the realSubject");
}


}

3、代理角色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* 代理模式里面的代理角色
* */
public class ProxySubject implements Subject {

private RealSubject rs;//代理角色所拥有的真实角色的引用,用于访问真实角色

@Override
public void request() {
if(rs == null) {
rs = new RealSubject();
}
rs.request();
add();
}

public void add() {
System.out.println("the extra function");
}

}

4、测试程序

1
2
3
4
5
6
7
8
9
10
11


public class Main {

public static void main(String[] args) {

Subject s = new ProxySubject();

s.request();
}
}

最终的输出结果:
this is the realSubject
the extra function
静态代理的流程:
1、使用抽象角色的引用 获得 代理角色的对象(在里面生成了真实角色的对象)
2、调用方法 (这里调用的是代理角色的同名方法,在实现了真实角色的方法的同时,添加了额外功能,上面的是add)

静态代理的优点:编写简单,理解也简单吧。
静态代理的缺点:每一个类如果要添加额外功能的时候,都要对应一个代理类,在多个类的方法的额外功能相同的情况下,将会产生大量重复的代码。
为了解决这个问题,所以有了动态代理。

五、动态代理
首先也先上代码
1、抽象角色(这个跟静态代理的一致)

1
2
3
4
5
6
7
8
9
10
11

/**
* 动态代理的接口类(抽象角色)
* */
public interface Hello {

void sayHello(String to);

void print(String p);

}

2、真实角色(这个也一致)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 真实角色
* */
public class HelloImpl implements Hello {

public void sayHello(String to) {
System.out.println("Say hello to " + to);
}

public void print(String s) {
System.out.println("print : " + s);
}

}

3、处理类(这个就跟静态代理的不一致了,先把代码看完,下面有详细讲解)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
* 相比静态代理的优点,这个是可以作为多个类的处理类的,比如添加事务的处理类。
* */
public class LogHandler implements InvocationHandler {

private Object dele;

public LogHandler(Object obj) {
this.dele = obj;
}


/**
* 代理是在这里为原本的类添加新的功能
* 这些能够用来进行用来为某些操作之前进行检查,特别是使用面向切面编程的时候。
* */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
doBefore();
Object result = method.invoke(dele, args);//这个是真正执行方法的地方
after();
return result;
}

private void doBefore() {
System.out.println("before....");
}

private void after() {
System.out.println("after....");
}
}

4、测试程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import java.lang.reflect.Proxy;

/**
* 测试程序
*
* */


public class ProxyTest {

public static void main(String[] args) {
HelloImpl impl = new HelloImpl();
LogHandler handler = new LogHandler(impl); //这里指定了代理类所拥有的真实角色
//这里把handler与新生成的代理类相关联 ,这里的动态代理的类是由jvM生成的,他所拥有的东西
//(1)一个handler(拥有一个真实角色),handler同时还有一个invoke方法并且我们自己能够给他添加相应的功能
//(2)生成的对象实现了了impl所实现的接口,也就是公共的接口
Hello hello = (Hello) Proxy.newProxyInstance(impl.getClass().getClassLoader(), impl.getClass().getInterfaces(), handler);
//这里无论访问哪个方法,都是会把请求转发到handler.invoke
hello.print("All the test"); //在这一步,java将会调用proxy内部的LogHandler的invoke方法,当调用方法的时候,调用方法的对象就是上面的impl,方法的参数就是这里的参数,java内部提供了将这里的参数转换成object的方法
hello.sayHello("Denny");
}

}

5、动态代理所用到的类和接口
(1)Proxy类:使用其中的newProxyInstance方法生成一个代理对象,这个对象是jvm内部帮助我们生成的,这个生成的就是代理角色.
方法的具体定义如下:

1
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException

loader:是真实角色的类加载器;
interfaces:是真实角色所实现的所有公有接口的数组,这个相当于是让代理角色实现了公有接口
InvocationHandler:是一个处理器类,里面拥有真实角色的实现,额外功能的附加以及核心方法的调用都是在里面实现的
(2)Interface InvocationHandler: 上面的处理器都要求要实现这个接口。里面有一个invoke方法

6、处理器(实现了InvocationHandler的类)的作用
(1)实现额外功能
(2)决定额外功能与和核心功能的调用顺序。
(3)当代理类调用某个方法的时候,就是调用这里的invoke();然后里面的method.invoke(obj,args)方法实际上就是利用反射调用真实角色的对应方法。
7、抽象角色
代理类:是动态生成的类(测试程序中的hello)通过newProxyInstance方法,在生成它的时候必须先提供接口给他,然后该类就宣布他实现了这些接口,但是实际上,他 不会完成实际的工作,他对接口里面的方法的调用,实际上是对真实角色方法的调用。
8、动态体现在哪里?
体现在代理类是在程序运行阶段才确定的,而不是在程序的编译阶段。

六、总结
静态代理和动态代理的比较
(1) 动态代理使得附加操作能够被多个类共同使用(或者说是附加操作能够与不同类的不同方法组装到一起)
(2) 组件之间的比较
真实角色:一样
接口:一样
代理角色:不一样;代理角色里面其实还是可以分类的:(1)附加的功能 (2)真实角色的引用
动态代理和静态代理最大的区别就是:静态代理将真实角色和附加功能绑定到了一起,而动态代理是将这两部分分成了两 个模块,使得他们能够任意组装成新的代理类。使得附加功能部分能够复用(handler)。
eg:还是数据库的事务,这些是所有数据库操作都共用的功能,这个时候他们就能够共用一个处理器了

分享到

一个包含模板方法的比较器栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

public class TemplateMethod {
void noName(){
UserModel um1 = new UserModel("张飞",28);
UserModel um2 = new UserModel("关羽",30);
UserModel um3 = new UserModel("刘备",32);
UserModel um4 = new UserModel("庞统",29);
UserModel um5 = new UserModel("曹操",34);
ArrayList<UserModel> list = new ArrayList<UserModel>();
list.add(um1);
list.add(um2);
list.add(um3);
list.add(um4);
list.add(um5);

System.out.println("排序前:------------");

printList(list);

Comparator<UserModel> c = new Comparator<UserModel>() {
public int compare(UserModel o1, UserModel o2) {
return o1.getuAge()-o2.getuAge();
};
};
Collections.sort(list,c);
System.out.println("排序后:----------------");
printList(list);
}
private void printList(ArrayList<UserModel> list) {
for (UserModel um : list) {
System.out.println(um);
}

}
public static void main(String[] args) {
TemplateMethod st = new TemplateMethod();
st.noName();
}

}
class UserModel{
String uName;
int uAge;
public UserModel() {}

@Override
public String toString() {
return "UserModel [uName=" + uName + ", uAge=" + uAge + "]";
}
public UserModel(String uName, int uAge) {
super();
this.uName = uName;
this.uAge = uAge;
}
public String getuName() {
return uName;
}
public void setuName(String uName) {
this.uName = uName;
}
public int getuAge() {
return uAge;
}
public void setuAge(int uAge) {
this.uAge = uAge;
}
}

分享到

代理模式是:一对象代替另外的对象进行操作。需要代理类和被代理类实现同样的接口

1
2
3
4
5
6
7
/**
* 代理模式 代理类和被代理类需要实现的接口
*
*/
public interface Business {
void doAction();
}

1
2
3
4
5
6
7
8
9
10
11
12
被代理类
/**
* 被代理类 需要实现接口
*
*/
public class BusinessImpl implements Business{

@Override
public void doAction() {
System.out.println("被代理类进行 真实操作");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
代理类
/**
* 代理类 需要现实被代理类相同的接口
*
*/
public class BusinessImplProxy implements Business{
private BusinessImpl businessImpl;
public BusinessImplProxy(){
businessImpl=new BusinessImpl();
}
@Override
public void doAction() {
doBefore();
businessImpl.doAction();
doAfter();
}
public void doBefore(){
System.out.println("真正操作之前");
}
public void doAfter(){
System.out.println("真正操作之后");
}
}
1
2
3
4
5
6
7
测试类
public class StaticTest {
public static void main(String[] args) {
BusinessImplProxy proxy = new BusinessImplProxy();
proxy.doAction();
}
}

传统代理用到的很少,用的最多的是动态代理
java最常用的两种动态代理方式
一.java提供基于Proxy、InvocationHandler的动态代理
只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 Proxy类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现。
JDK的动态代理用起来非常简单,但它有一个限制,就是使用动态代理的对象必须实现一个或多个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//抽象角色:java动态代理的实现目前只支持接口,不支持抽象类
interface BusinessFoo {
void foo();
}

interface BusinessBar {
String bar(String message);
}

// 真实角色:真正实现业务逻辑方法
class BusinessFooImpl implements BusinessFoo {
public void foo() {
System.out.println("BusinessFooImpl.foo()");
}
}

class BusinessBarImpl implements BusinessBar {
public String bar(String message) {
System.out.println("BusinessBarImpl.bar()");
return message;
}
}

// 动态角色:动态生成代理类
class BusinessDynamicProxy implements InvocationHandler {
private Object obj;

BusinessDynamicProxy() {
}

BusinessDynamicProxy(Object obj) {
this.obj = obj;
}

public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
doBefore();
result = method.invoke(obj, args);
doAfter();
return result;
}

public void doBefore() {
System.out.println("do something before Business Logic");
}

public void doAfter() {
System.out.println("do something after Business Logic");
}

/**
* 工厂方法
*/
public static Object factory(Object obj) {
Class<? extends Object> cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),
cls.getInterfaces(), new BusinessDynamicProxy(obj));
}
}

public class DynamicProxy {
public static void main(String[] args) {
BusinessFooImpl bfoo = new BusinessFooImpl();
BusinessFoo bf = (BusinessFoo) BusinessDynamicProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = new BusinessBarImpl();
BusinessBar bb = (BusinessBar) BusinessDynamicProxy.factory(bbar);
String message = bb.bar("Hello,World");
System.out.println(message);
}
}

二.基于第三方开源框架cglib
cglib官方网站:http://sourceforge.net/projects/cglib/files/
另外cglib依赖于asm(http://asm.ow2.org/)。
Cglib的原理是对指定的目标类动态生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类和final方法进行代理。
参考:http://blog.csdn.net/zhoudaxia/article/details/30591941

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MethodInterceptorImpl implements MethodInterceptor {

@Override
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("Before invoke " + method);
Object result = proxy.invokeSuper(obj, args);
System.out.println("After invoke" + method);
return result;
}
public Object createProxy(Class<?> targetClass) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass);
enhancer.setCallback(this);
return enhancer.create();
}
}

public class HelloWorld {
public void sayHelloWorld() {
System.out.println("HelloWorld!");
}
}

public class Test {
public static void main(String[] args) {
MethodInterceptorImpl mImpl=new MethodInterceptorImpl();
HelloWorld helloWorld= (HelloWorld) mImpl.createProxy(HelloWorld.class);
helloWorld.sayHelloWorld();
}
}

代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。
代理模式的结构

  所谓代理,就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下,一个客户不想或者不能够直接引用一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
  代理模式类图如下:
  在代理模式中的角色:
  ●  抽象对象角色:声明了目标对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。
  ●  目标对象角色:定义了代理对象所代表的目标对象。
  ●  代理对象角色:代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象;代理对象提供一个与目标对象相同的接口,以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后,执行某个操作,而不是单纯地将调用传递给目标对象。
源代码

抽象对象角色

1
2
3
public	abstract	class AbstractObject {
//操作publicabstractvoid operation();
}

目标对象角色

1
2
3
4
5
6
7
public	class RealObject extends AbstractObject {
@Override
publicvoid operation() {
//一些操作
System.out.println("一些操作");
}
}

代理对象角色

1
2
3
4
5
6
7
8
9
10
11
public	class ProxyObject extends AbstractObject{
RealObject realObject = new RealObject();
@Override
publicvoid operation() {
//调用目标对象之前可以做相关操作
System.out.println("before");
realObject.operation();
//调用目标对象之后可以做相关操作
System.out.println("after");
}
}

  客户端

1
2
3
4
5
6
7
8
9
publicclass Client {

publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
AbstractObject obj = new ProxyObject();
obj.operation();
}

}

分享到

单例模式

单例模式主要有三个部分:
1.私有构造方法:防止外部实例化,只有内部可以实例化
2.有一全局静态方法:
(1).可以访问私有的构造方法进行实例化。
(2).外部调用静态方法,如果存在singleton实例就返回,如果不存在则创建一个实例.自己进行对实例进行管理.
3.静态变量:利用一个静态变量来记录Singleton的唯一实例。

uml图

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Singleton{

//利用一个静态变量来记录Singleton类的唯一实例
private static Singleton uiqueInstance;

//把构造函数声明为私有的,外部不可以实例化,只有内部可以实例化
private Singleton(){

}

//外部通过调用静态方法getInstance(),来获得实例化对象
public static Singleton getInstance(){
//内部自己管理实例,始终保证只有一个实例

if(uniqueInstance == null) {
//如果没有实例,则创建实例,在类的内部可以访问构造函数,进而实例化
uniqueInstance = new Singleton();
}
//如果已经存在就直接将实例返回就行了
return uniqueInstance;
}
}

饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
* 饿汉式单例模式:在类被加载的时候,唯一实例已经被创建
*/
public class HungrySingleton {
public static final HungrySingleton singleton = new HungrySingleton();
private HungrySingleton(){} //私有构造方法,避免外部创建实例

public static HungrySingleton getInstance(){
return singleton;
}
}
// ----------------
/**
* 通用的饿汉式单例模式 ,解决多线程访问的问题
*/
public class SingletonPattern {
private static final SingletonPattern singletonPattern = new SingletonPattern();

private SingletonPattern(){}//私有构造方法,避免外部创建实例

public static synchronized SingletonPattern getInstance(){
return singletonPattern;
}
}

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* 懒汉单例模式:只有在第一次请求实例的时候的时候创建,并且只在第一次创建后,以后不再创建该类的实例。
*/
public class LazySingleton {
private static LazySingleton singleton = null;
private LazySingleton(){} //私有构造方法,避免外部创建实例
public static LazySingleton getInstance(){
if(singleton == null){
singleton = new LazySingleton();
}
return singleton;
}
}
/// ------------

/**
* 通用的懒汉式单例模式 ,解决多线程访问的问题
*/
public class SingletonPattern {
private static SingletonPattern singletonPattern = null;

private SingletonPattern(){}//私有构造方法,避免外部创建实例

public static synchronized SingletonPattern getInstance(){
if(singletonPattern == null){
singletonPattern = new SingletonPattern();
}
return singletonPattern;
}
}

登陆式单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.HashMap;
import java.util.Map;

/**
* 登记式单例实际上维护的是一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,
* 则从工厂直接返回,对于没有登记的,则先登记,而后返回.
* 登记式单例类是为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的.当单例类需要被继承时适用.
*/
public class RegisterSingleton {
private static Map<String, RegisterSingleton> map = new HashMap<String, RegisterSingleton>();
static {
RegisterSingleton singleton = new RegisterSingleton();
map.put(singleton.getClass().getName(), singleton);
}

protected RegisterSingleton() {}// 受保护的构造函数

public static RegisterSingleton getInstance(String name) {
if (name == null) {
name = RegisterSingleton.class.getName();
System.out.println(name);
}
if (map.get(name) == null) {
try {
map.put(name, (RegisterSingleton) Class.forName(name)
.newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
return map.get(name);
}
}
//---------------------------
package pattern.singleton;

public class RegisterSingletonChild extends RegisterSingleton{

public static RegisterSingletonChild getInstance(){
return (RegisterSingletonChild)RegisterSingleton.getInstance("pattern.singleton.RegisterSingletonChild");
}

public static void main(String[] args) {
RegisterSingletonChild.getInstance();
RegisterSingleton.getInstance("pattern.singleton.RegisterSingletonChild");
}
}
`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class SingletonClass {

private static SingletonClass instance = null;

public static SingletonClass getInstance() {
if (instance == null) {
synchronized (SingletonClass.class) {
if (instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}

private SingletonClass() {

}

/*
还有问题吗?首先判断instance是不是为null,如果为null,加锁初始化;如果不为null,直接返回instance。

这就是double-checked locking设计实现单例模式。到此为止,一切都很完美。我们用一种很聪明的方式实现了单例模式。
*/
}
  1. 从源头检查

下面我们开始说编译原理。所谓编译,就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。针对Java,它的目标代码不是本地机器代码,而是虚拟机代码。编译原理里面有一个很重要的内容是编译器优化。所谓编译器优化是指,在不改变原来语义的情况下,通过调整语句顺序,来让程序运行的更快。这个过程成为reorder。

要知道,JVM只是一个标准,并不是实现。JVM中并没有规定有关编译器优化的内容,也就是说,JVM实现可以自由的进行编译器优化。

下面来想一下,创建一个变量需要哪些步骤呢?一个是申请一块内存,调用构造方法进行初始化操作,另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢?JVM规范并没有规定。那么就存在这么一种情况,JVM是先开辟出一块内存,然后把指针指向这块内存,最后调用构造方法进行初始化。

下面我们来考虑这么一种情况:线程A开始创建SingletonClass的实例,此时线程B调用了getInstance()方法,首先判断instance是否为null。按照我们上面所说的内存模型,A已经把instance指向了那块内存,只是还没有调用构造方法,因此B检测到instance不为null,于是直接把instance返回了——问题出现了,尽管instance不为null,但它并没有构造完成,就像一套房子已经给了你钥匙,但你并不能住进去,因为里面还没有收拾。此时,如果B在A将instance构造完成之前就是用了这个实例,程序就会出现错误了!

于是,我们想到了下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class SingletonClass {

private static SingletonClass instance = null;

public static SingletonClass getInstance() {
if (instance == null) {
SingletonClass sc;
synchronized (SingletonClass.class) {
sc = instance;
if (sc == null) {
synchronized (SingletonClass.class) {
if(sc == null) {
sc = new SingletonClass();
}
}
instance = sc;
}
}
}
return instance;
}

private SingletonClass() {

}

}

我们在第一个同步块里面创建一个临时变量,然后使用这个临时变量进行对象的创建,并且在最后把instance指针临时变量的内存空间。写出这种代码基于以下思想,即synchronized会起到一个代码屏蔽的作用,同步块里面的代码和外部的代码没有联系。因此,在外部的同步块里面对临时变量sc进行操作并不影响instance,所以外部类在instance=sc;之前检测instance的时候,结果instance依然是null。

不过,这种想法完全是错误的!同步块的释放保证在此之前——也就是同步块里面——的操作必须完成,但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。因此,编译器完全可以把instance=sc;这句移到内部同步块里面执行。这样,程序又是错误的了!

  1. 解决方案

说了这么多,难道单例没有办法在Java中实现吗?其实不然!

在JDK 5之后,Java使用了新的内存模型。volatile关键字有了明确的语义——在JDK1.5之前,volatile是个关键字,但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整,读变量不能和之后的读写代码调整!因此,只要我们简单的把instance加上volatile关键字就可以了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SingletonClass {

private volatile static SingletonClass instance = null;

public static SingletonClass getInstance() {
if (instance == null) {
synchronized (SingletonClass.class) {
if(instance == null) {
instance = new SingletonClass();
}
}
}
return instance;
}

private SingletonClass() {

}

}

推荐方法:

然而,这只是JDK1.5之后的Java的解决方案,那之前版本呢?其实,还有另外的一种解决方案,并不会受到Java版本的影响:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SingletonClass {

private static class SingletonClassInstance {
private static final SingletonClass instance = new SingletonClass();
}

public static SingletonClass getInstance() {
return SingletonClassInstance.instance;
}

private SingletonClass() {

}

}

在这一版本的单例模式实现代码中,我们使用了Java的静态内部类。这一技术是被JVM明确说明了的,因此不存在任何二义性。在这段代码中,因为SingletonClass没有static的属性,因此并不会被初始化。直到调用getInstance()的时候,会首先加载SingletonClassInstance类,这个类有一个static的SingletonClass实例,因此需要调用SingletonClass的构造方法,然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是static的,因此并不会构造多次。

由于SingletonClassInstance是私有静态内部类,所以不会被其他类知道,同样,static语义也要求不会有多个实例存在。并且,JSL规范定义,类的构造必须是原子性的,非并发的,因此不需要加同步块。同样,由于这个构造是并发的,所以getInstance()也并不需要加同步。

至此,我们完整的了解了单例模式在Java语言中的时候,提出了两种解决方案。个人偏向于第二种,并且Effiective Java也推荐的这种方式。

single内存

  1. 虚拟机加载StaticDemo类,保存类型信息到方法区。

  2. 通过保存在方法区的字节码,虚拟机开始main方法,main方法入栈。

3:进入main方法第一条指令, Person.getInstance(); 首先虚拟机加载Person类到方法区,然后完成对Person类的初始化操作。
疑问来了,类变量不是保存在方法区吗?图中的私有实例对象为什么保存在堆区呢?那就要来了解一下类的初始化过程了,过程如下:
1:装载,通过类的全名产生对应类的二进制数据流,分析二进制数据流并转换为方法区特定的数据结构,创建对应类的java.lang.Class实例。
2:链接,
分为检测(确保被导入类型的正确性。),
准备(为类变量分配内存,并将其初始化为默认值),
解析(把类型中的符号引用转换成直接引用)三步。
3:初始化,把类变量(static)初始化为正确初始值。
类变量的初始化(有赋值操作),无论是基本数据类型还是引用数据类型,类变量的初始化都会被提取到clinit方法中。
常量的初始化,对于基本数据类型来说,会直接被编译器生成constant值。而对于引用数据类型常量的初始化会被提取到clinit方法中。
步骤3初始化是把类变量初始化为正确初始值,我们现在初始化的是实例对象,只要是new操作,都会在堆区分配空间。

4:调用getInstance()方法,方法返回实例对象的引用,getInstance()方法执行完毕出栈,程序回到main方法。

5:调用say()方法,根据引用变量p持有的引用,在堆中找到实例对象,根据实例对象持有的本来在方法区的引用,找到本类的类型信息,定位到say()方法。say()方法入栈,开始执行其中的字节码。

6:say()方法执行完毕出栈,程序回到main方法,main方法执行完毕出栈,主线程消亡。虚拟机实例消亡。程序结束。

总结:单例模式的实现,new操作依旧是在堆中为实例对象分配空间,然后在方法区保存共享实例引用。为什么说静态变量(类变量)的生命周期跟类一样呢?
这是因为实例对象的引用在方法区保存,除非类被卸载了,该实例对象才不会被引用了,然后被GC回收。否则,一直都在。
引用类型变量是静态的,对象不是静态的,我们在程序传递的都是引用,永远不会直接操作对象。

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* A test for SingletonA
*/
public class TestA {
public static void main(String[] args) {
// Can not create a instance !
//SingletonA instance1 = new SingletonA();
SingletonA instance2 = SingletonA.getInstance();
if(instance2 != null) {
instance2.setNum();
System.out.println("i is:" + instance2.getNum());
}
SingletonA instance3 = SingletonA.getInstance();
if(instance3 == null) {
System.out.println("Can not get instance twice !");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
* Test for our Singleton registry
*/
public class TestB {
public static void main(String[] args) {
// First we get a instance from SingletonB
SingletonB instance1 = SingletonB.GetInstance("Sub1");
if(instance1 == null) {
System.out.println("There is no such instance in registry !");
} else {
System.out.println(instance1.getClass());
}

// Then we register a new instance
try {
SingletonB instance2 = new SubSingletonB();
System.out.println("We had created a new instance named \"Sub1\" now");
} catch (SingletonException e) {
System.out.println(e.getMessage());
}

// To get instance again
instance1 = SingletonB.GetInstance("Sub1");
if(instance1 == null) {
System.out.println("There is no such instance in registry !");
} else {
System.out.println(instance1.getClass());
}

// Finally we create a new instance again
try {
SingletonB instance3 = new SubSingletonB();
System.out.println("We had created a new instance named \"Sub1\" now");
} catch (SingletonException e) {
System.out.println(e.getMessage());
}

}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* A new Singleton use registry
*/
import java.util.*;

public class SingletonB {
static private Hashtable registry = new Hashtable();
//static private SingletonB instance;

public static void Register(String name, SingletonB aInstance) {
registry.put(name, aInstance);
}
public static SingletonB GetInstance(String name) {
return LookUp(name);
}

protected static SingletonB LookUp(String name) {
return (SingletonB)registry.get(name);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* A real Singleton we want to have
*/
public class SubSingletonB extends SingletonB {
public static boolean instanceFlag = false; //true if 1 instance
//private int i = 0;

public SubSingletonB() throws SingletonExecption {
if(instanceFlag) {
throw new SingletonExecption("Only can create a instance !");
} else {
instanceFlag = true;
super.Register("Sub1", this);
}
}

public void finalize() {
instanceFlag = false;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* A user defined exception
*/
public class SingletonException extends RuntimeException {
public SingletonException() {
super();
}

public SingletonException(String s) {
super(s);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
* A Singleton , we can only create one instance
*/
public class SingletonA {
public static boolean instanceFlag = false; //true if 1 instance
//private SingletonA instance;
private int i = 0;

// Set constructor private and do nothing
// Can not new a instance outside class
private SingletonA() {
}

public int getNum() {
return i;
}

public void setNum() {
i++;
}

public static SingletonA getInstance() {
if(! instanceFlag) {
instanceFlag = true;
return new SingletonA();
}
return null;
}

public void finalize() {
instanceFlag = false;
}
}
分享到
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

import java.util.Comparator;
import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;

/*
*
* 红色球 (1-33 不能重复出6个数) 蓝色球(1-16 出一个数)
结果模式:01,05,23,28,29,33-05 **/
public class TicketResult {
private TicketResult(){}
//把每期结果作为属性私有化,且静态化,每次JVM运行(运行一次程序)初始化该类时,即为该属性赋值且不论这次运行创建多少个对象只返回一个同一个值
private static final String result = getResult();
public static String getFinallyResult(){
return result;
}

/**
* 利用TreeSet装入红色球选出的值(1.值不重复 2.利用默认比较器或自定义比较器可以实现排序)
* @return
*/
private static TreeSet<Integer> getRedBall(){
TreeSet<Integer> set = new TreeSet<Integer>(new MyComparator());
Random ran = new Random();
//保证只取6个不重复的值
while(set.size()<6){
//nextInt(int n) 方法:随机产生0~n(包括0,不包括n)之间的int值
set.add(ran.nextInt(33)+1);
}
return set;
}

/**
* 获取特殊号码值
* @return
*/
private static int getBlueBall(){
Random ran = new Random();
return ran.nextInt(16)+1;
}

/**
* 拼接字符串,返回固定格式的开奖结果
* @return
*/
private static String getResult(){
TreeSet<Integer> set = getRedBall();
int blue = getBlueBall();
Iterator<Integer> it = set.iterator();
StringBuffer sbf = new StringBuffer();
while(it.hasNext()){
int temp =it.next();
//把1,2,3...等转为01,02,03...
if(temp<10)
sbf.append("0"+temp+",");
else
sbf.append(temp+",");
}
String result = sbf.toString().substring(0,sbf.toString().lastIndexOf(","));
result = result +"-"+blue;
return result;
}
}

/**
* 自定义比较器
* @author ml1990s
*
*/
class MyComparator implements Comparator<Integer>{

@Override
public int compare(Integer o1, Integer o2) {

return o1-o2;
}


}

测试

1
2
3
4
5
6
7
8
9
public class Test {

public static void main(String[] args) {
System.out.println(TicketResult.getFinallyResult());
System.out.println(TicketResult.getFinallyResult());

}

}
分享到

栗子

GraphicTool.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
* As a Test Client to test our pattern
*/
import java.util.*;
import java.lang.*;

public class GraphicTool {
public GraphicTool() {
}

public static void main(String[] args) {
//----- Initial our prototype instance ----------
SymbolLoader myLoader = new SymbolLoader();
Hashtable mySymbols = myLoader.getSymbols();

//----- Draw a Line -------------------------------
Graphic myLine = (Graphic)((Graphic)mySymbols.get("Line")).clone();
myLine.DoSomething();
}

1
2
3
4
5
6
7
8
9
/*
* A Graphic Interface ( A prototype interface )
*/
import java.io.*;

public interface IGraphic extends Cloneable, Serializable {
public String getName() ;
public void setName(String gName);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
* An Abstract Graphic Class ( Prototype )
*/
import java.lang.*;
import java.io.*;

public abstract class Graphic implements IGraphic {
private String name;

public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e){
System.out.println("Do not support clone !!!");
throw new InternalError();
}
}

public String getName() {
return name;
}

public void setName(String gName) {
name = gName;
}

public abstract void DoSomething();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
* A Symbol Loader to register all prototype instance
*/
import java.util.*;

public class SymbolLoader {
private Hashtable symbols = new Hashtable();
public SymbolLoader() {
symbols.put("Line", new LineSymbol());
symbols.put("Note", new NoteSymbol());
}
public Hashtable getSymbols() {
return symbols;
}
}
1
2
3
4
5
6
7
8
9
10
11
/*
* A concrete prototype to draw a note
*/
public class NoteSymbol extends Graphic {
public NoteSymbol() {
}

public void DoSomething() {
System.out.println("I am used to draw a note !");
}
}
1
2
3
4
5
6
7
8
9
10
11
/*
* A concrete prototype to draw a line
*/
public class LineSymbol extends Graphic {
public LineSymbol() {
}

public void DoSomething() {
System.out.println("I am used to draw a line !");
}
}
分享到

Java命令模式(Command模式)

作者:guxiaonuan
Command模式是最让我疑惑的一个模式,我在阅读了很多代码后,才感觉隐约掌握其大概原理,我认为理解设计模式最主要是掌握起原理构造,这样才对自己实际编程有指导作用。Command模式实际上不是个很具体,规定很多的模式,正是这个灵活性,让人有些confuse。

Command定义

不少Command模式的代码都是针对图形界面的,它实际就是菜单命令,我们在一个下拉菜单选择一个命令时,然后会执行一些动作。

将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,这就是Command模式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),就直接指向打开文档的代码,使用Command模式,就是在这两者之间增加一个中间者,将这种直接关系拗断,同时两者之间都隔离,基本没有关系了。

显然这样做的好处是符合封装的特性,降低耦合度,Command是将对行为进行封装的典型模式,Factory是将创建进行封装的模式。

从Command模式,我也发现设计模式一个”通病”:好象喜欢将简单的问题复杂化,喜欢在不同类中增加第三者,当然这样做有利于代码的健壮性 可维护性 还有复用性。

如何使用命令模式

具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法。下面事例是将命令封装在一个Collection的List中,任何对象一旦加入List中,实际上装入了一个封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出。

典型的Command模式需要有一个接口。接口中有一个统一的方法,这就是”将命令/请求封装为对象”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public interface Command {
  public abstract void execute ( );
}
具体不同命令/请求代码是实现接口Command,下面有三个具体命令:
public class Engineer implements Command {
  public void execute( ) {
    //do Engineer's command
  }
}

public class Programmer implements Command {
  public void execute( ) {
    //do programmer's command
  }
}

public class Politician implements Command {
  public void execute( ) {
    //do Politician's command
  }
}

按照通常做法,我们就可以直接调用这三个Command,但是使用Command模式,我们要将他们封装起来,扔到黑盒子List里去:

1
2
3
4
5
6
7
8
9
public class producer{
  public static List produceRequests() {
    List queue = new ArrayList();
    queue.add( new DomesticEngineer() );
    queue.add( new Politician() );
    queue.add( new Programmer() );
    return queue;
  }
}

这三个命令进入List中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是Engineer 谁是Programmer了,看下面如何调用Command模式:

1
2
3
4
5
6
7
8
9
public class TestCommand {
  public static void main(String[] args) {
    List queue = Producer.produceRequests();
    for (Iterator it = queue.iterator(); it.hasNext(); )
        //取出List中东东,其他特征都不能确定,只能保证一个特征是100%正确,
        // 他们至少是接口Command的"儿子".所以强制转换类型为接口Command
        ((Command)it.next()).execute();
  }
}

由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了。

理解了上面的代码的核心原理,在使用中,就应该各人有自己方法了,特别是在如何分离调用者和具体命令上,有很多实现方法,上面的代码是使用”从List过一遍”的做法。这种做法只是为了演示。

使用Command模式的一个好理由还因为它能实现Undo功能,每个具体命令都可以记住它刚刚执行的动作,并且在需要时恢复。

Command模式在界面设计中应用广泛。Java的Swing中菜单命令都是使用Command模式,由于Java在界面设计的性能上还有欠缺,因此界面设计具体代码我们就不讨论,网络上有很多这样的示例。
更多内容请参考:http://see.xidian.edu.cn/biancheng/java/shejimoshi/

案例

情景:某个方法需要实现一个行为,但是这个行为的具体实现却无法确定,必须等到执行这个方法的时候才能确定。
考虑:这个方法不仅需要普通数据可以变化,而且方法执行体也需要改变,将“处理行为”作为一个参数传入该方法不失为一种方法
结论:但是java目前的jdk1.6版本不想Ruby语言支持袁旭传入一个代码块作为参数
如何实现这种呢,假如一个方法需要遍历一组数组,但是无法确定在遍历的时候如何处理这些数据,需要在调用该方法时指定具体的做法:
interface:

1
2
3
4
5
6
public interface Command {
//由于jdk1.6中不允许传入一个代码块作为参数,
//这里定义一个方法来封装 处理过程
void process(int [] target);
}
`

两个处理过程接口实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class AddCommand implements Command {

@Override
public void process(int[] target) {
int sum=0;
for(int k:target){
sum+=k;
}
System.out.println("数组和是:"+sum);

}

}
public class PrintCommand implements Command {


@Override
public void process(int[] target) {
for(int k :target){
System.out.println("依次输出数组元素:"+k);
}

}


}


ProcessArray(处理类):
public class ProcessArray {
public void process(int [] target,Command cmd){
cmd.process(target);
}
}


TestCommand(测试类):
public class TestCommand {
public static void main(String [] args){
ProcessArray pra=new ProcessArray();
int [] target={1,2,3,4,5};
//处理行为依赖于PrintCommand
pra.process(target, new PrintCommand());
System.out.println("******");
//处理行为依赖于AddCommand()
pra.process(target, new AddCommand());
}

对于上面两个Print和AddCommand实现类,就是为了实现方法process(int 【】 target),而该方法也就是处理类ArrayProcess里process方法的处理行为。
这样,就实现process方法和处理行为的分离。

分享到

栗子

1
2
3
4
5
6
7
8
/*
* An abstract Builder
*/
public abstract class HouseBuilder {
public abstract void BuildRoom(int roomNo);
public abstract void BuildDoor(int room1, int room2);
public abstract House getHouse();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ConcreteHouseBuilderA  extends HouseBuilder{
private House house;
public ConcreteHouseBuilderA() {
house = new House();
}
public void BuildRoom(int roomNo) {
//you can create a new Room added to a House
house.roomNumber++;
}

public void BuildDoor(int room1, int room2) {
// you can create a new door assotiated with 2 room
// and added this door into a house
house.doorNumber++;
}

public House getHouse() {
return house;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
* A house as a concrete product we got finally
*/
public class House {
int roomNumber;
int doorNumber;
public House() {
roomNumber = 0;
doorNumber = 0;
}
public int getRoomNumber() {
return roomNumber;
}

public int getDoorNumber() {
return doorNumber;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
/*
* This class is a Director
*/
public class HouseDirector {
public void CreateHouse(HouseBuilder concreteBuilder) {
concreteBuilder.BuildRoom(1);
concreteBuilder.BuildRoom(2);
concreteBuilder.BuildDoor(1, 2);

//return builder.getHouse();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
* A test client to create a house
* but we do not know how the room and door be created
*/
public class TestClient {
public TestClient() {
}

public static void main(String[] args) {
House myHouse = new House();
ConcreteHouseBuilderA myHouseBuilder = new ConcreteHouseBuilderA();
HouseDirector myHouseDirector = new HouseDirector();
myHouseDirector.CreateHouse(myHouseBuilder);
myHouse = myHouseBuilder.getHouse();

System.out.println("My house has room :" + myHouse.getRoomNumber());
System.out.println("My house has door :" + myHouse.getDoorNumber());
}
}
分享到

一、定义
备忘录模式(Memento)的作用是保存对象的内部状态,并在需要的时候(undo/rollback)恢复对象以前的状态。在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样就可以在需要的时候将该对象恢复到原先保存的状态。
二、结构图
备忘录模式
涉及的角色:发起人(Originator)角色、备忘录(Memento)角色、负责人(Caretaker)角色。
发起人(Originator)角色:负责创建一个备忘录Memento对象,用以存储当前时刻Originator自己的内部状态,Originator可以根据需要决定将自己的哪些状态信息存储在Memento对象中,并可使用备忘录恢复内部状态;
备忘录(Memento)角色:负责存储Originator对象的内部状态,并可以防止Originator以外的其他对象访问备忘录。备忘录有两个接口:Caretaker只能看到备忘录的窄接口,它只能将备忘录对象传递给其他对象。Originator却可看到备忘录的宽接口,这个接口允许它读取所有的数据,以便根据这些数据回复这个发起人的内部状态;
负责人(Caretaker)角色:责在适当的时间保存/恢复Originator对象的状态,不检查备忘录对象的内容。
三、程序实例
//发起者类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Originator {
private String state;

public String getState() {
return state;
}

public void setState(String state) {
this.state = state;
}

public Memento createMemento() {
return new Memento(this.state);
}

public void cancelMemento(Memento memento) {
this.setState(memento.getState());
}
}

1
2
3
4
5
6
7
8
9
10
11
12
//备忘录类
public class Memento {
private String state;

public Memento(String state) {
this.state = state;
}

public String getState() {
return state;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
//管理这类
public class Caretaker {
private Memento memento;

public Memento getMemento() {
return memento;
}

public void setMemento(Memento memento) {
this.memento = memento;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//测试类
public class MementoTest {

public static void main(String[] args) {
Originator originator = new Originator();
originator.setState("状态1");
System.out.println("初始状态:" + originator.getState());
//创建一个管理者
Caretaker caretaker = new Caretaker();
// 将originator的状态1保存在备忘录中
caretaker.setMemento(originator.createMemento());
// 改变originator的状态
originator.setState("状态2");
System.out.println("改变后状态:" + originator.getState());
//撤销上一步的修改动作。恢复到第一步的状态
originator.cancelMemento(caretaker.getMemento());
System.out.println("恢复后状态:" + originator.getState());
}
}

测试结果:
初始状态:状态1
改变后状态:状态2
恢复后状态:状态1
代码演示了一个单状态单备份的例子,逻辑非常简单:Originator类中的state变量需要备份,以便在需要的时候恢复;Memento类中,也有一个state变量,用来存储Originator类中state变量的临时状态;而Caretaker类就是用来管理备忘录类的,用来向备忘录对象中写入状态或者取回状态。
四、应用场景
1、备忘录模式比较适用功能比较复杂,需要维护或者记录属性历史的类,或者需要保存的属性是众多属性中的很小部分,Originator可以根据保存的Memento信息还原到前一状态;
2、如果在程序的使用到命令模式的撤销功能,那么可以用备忘录模式存储可撤销操作的状态;
3、当角色的状态改变时,有可能这个状态无效,这个时候可以使用暂时存储的Memento将状态复原。
五、优缺点
优点:①有时一些发起人对象的内部信息必须保存在发起人对象以外的地方,但是必须要由发起人对象自己读取,这时,使用备忘录模式可以把复杂的发起人内部信息对其他的对象屏蔽起来,从而可以恰当地保持封装的边界。②本模式简化了发起人类,发起人不再需要管理和保存其内部状态的一个个版本,客户端可以自行管理他们所需要的这些状态的版本;③当发起人角色的状态改变的时候,有可能这个状态无效,这时候就可以使用暂时存储起来的备忘录将状态复原。
缺点:①如果发起人角色的状态需要完整地存储到备忘录对象中,那么在资源消耗上面备忘录对象会很昂贵。②当负责人角色将一个备忘录 存储起来的时候,负责人可能并不知道这个状态会占用多大的存储空间,从而无法提醒用户一个操作是否很昂贵;③当发起人角色的状态改变的时候,有可能这个协议无效。如果状态改变的成功率不高的话,不如采取“假如”协议模式。

转载一个备忘录模式的实现方法
一、定义:备忘录(memento)模式又叫快照(snapshot)模式或者token模式,主要功能:
备忘录模式是用一个对象来存储另外一个对象的内部状态的快照,实现备忘录模式的关键点是在不破坏封装的
情况下,将一个对象的状态捕捉住,并外部化,存储起来,从而可以在合适的时候,把这个对象还原。
说明:备忘录模式适模式中比较好理解的一个,这里就不举例子,但是备忘录模式是模式中实现比较难,或者说
实现比较巧的,这里主要说说。
二、备忘录模式的实现
1,备忘录模式中的角色
发起人:创建含有内部状态的备忘录对象,并使用备忘录对象存储状态
负责人:负责人保存备忘录对象,但不检查备忘录对象的内容
备忘录:备忘录对象将发起人对象的内部状态存起来,并保正其内容不被发起人对象之外的对象像读取
注意:在备忘录的角色中,定义了他必须对不同的人提供不同的接口,对发起人提供宽接口,对其它任何人提供窄
接口。也许你说我都提供宽接口得了。对这也是备忘录的一种实现,叫做白箱备忘录,不过这种方法的封装没有设计
好,安全性不够好。
2,白箱备忘录的实现:

白箱的优点:实现简单
白箱的缺点:上边说了,破坏了封装,安全性有些问题。
说明:这里白箱的实现只保存了一个状态,其实是可以保存多个状态的。
3,双接口的实现,宽窄接口(黑箱)
如何实现宽窄接口呢,内部类也许是个好方法。我们把备忘录类设计”成发起人”的内部类,但这样还有的问题是同一
package中的其它类也能访问到,为了解决这个问题,我们可以把”备忘录”的方法设计成私有的方法,这样就
可以保正封装,又保正发起人能访问到。实现如下:
定义窄接口.

ok,实现了对大多数人实现比较窄的接口,对Originator实现了宽接口.
三,最后的一些说明:
1,前边两个例子都是记录了单个状态(单check点),要实现多个状态点很容易,只须要把记录state的字符串换
成一个list,然後添加,取得。如果须要随机须得状态点,也可以用map来存放.这样多个check点就实现了。
2,一般情况下可以扩展负责人的功能,让负责人的功能更强大,从而让客户端的操做更少些。解放客户端。
3,自述历史模式,这个就是把发起人,负责人写在一个类中,平时的应用中这种方法比较常见。

分享到

设计模式(Design Patterns) ——可复用面向对象软件的基础

一、设计模式的分类
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类:并发型模式和线程池模式。用一个图片来整体描述一下:

设计模式之间关系

二、设计模式的六大原则
1、开闭原则(Open Close Principle)
开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。
2、里氏代换原则(Liskov Substitution Principle)
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里 氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现 抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则(Dependence Inversion Principle)
这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。
5、迪米特法则(最少知道原则)(Demeter Principle)
为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式,而不是使用继承。
三、Java的23中设计模式
从这一块开始,我们详细介绍Java中23种设计模式的概念,应用场景等情况,并结合他们的特点及设计模式的原则进行分析。
1、工厂方法模式(Factory Method)
工厂方法模式分为三种:
11、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图:

举例如下:(我们举一个发送邮件和短信的例子)
首先,创建二者的共同接口:

1
2
3
public interface Sender {  
public void Send();
}

其次,创建实现类:

1
2
3
4
5
6
public class MailSender implements Sender {  
@Override
public void Send() {
System.out.println("this is mailsender!");
}
}

1
2
3
4
5
6
7
public class SmsSender implements Sender {  

@Override
public void Send() {
System.out.println("this is sms sender!");
}
}

最后,建工厂类:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SendFactory {  

public Sender produce(String type) {
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
}

我们来测试下:

1
2
3
4
5
6
7
8
public class FactoryTest {  

public static void main(String[] args) {
SendFactory factory = new SendFactory();
Sender sender = factory.produce("sms");
sender.Send();
}
}

输出:this is sms sender!
22、多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。关系图:
工厂方法
将上面的代码做下修改,改动下SendFactory类就行,如下:

1
2
3
4
5
6
7
8
9
public class SendFactory {  
public Sender produceMail(){
return new MailSender();
}

public Sender produceSms(){
return new SmsSender();
}
}

测试类如下:

1
2
3
4
5
6
7
8
public class FactoryTest {  

public static void main(String[] args) {
SendFactory factory = new SendFactory();
Sender sender = factory.produceMail();
sender.Send();
}
}

输出:this is mailsender!
33、静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

1
2
3
4
5
6
7
8
9
10
public class SendFactory {  

public static Sender produceMail(){
return new MailSender();
}

public static Sender produceSms(){
return new SmsSender();
}
}

1
2
3
4
5
6
7
public class FactoryTest {  

public static void main(String[] args) {
Sender sender = SendFactory.produceMail();
sender.Send();
}
}

输出:this is mailsender!
总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传 入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。
2、抽象工厂模式(Abstract Factory)
工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑, 有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。因为抽象 工厂不太好理解,我们先看看图,然后就和代码,就比较容易理解。
抽象工厂方法
请看例子:

1
2
3
public interface Sender {  
public void Send();
}

两个实现类:

1
2
3
4
5
6
public class MailSender implements Sender {  
@Override
public void Send() {
System.out.println("this is mailsender!");
}
}

1
2
3
4
5
6
7
public class SmsSender implements Sender {  

@Override
public void Send() {
System.out.println("this is sms sender!");
}
}

两个工厂类:

1
2
3
4
5
6
7
public class SendMailFactory implements Provider {  

@Override
public Sender produce(){
return new MailSender();
}
}

1
2
3
4
5
6
7
public class SendSmsFactory implements Provider{  

@Override
public Sender produce() {
return new SmsSender();
}
}

在提供一个接口:

1
2
3
public interface Provider {  
public Sender produce();
}

测试类:

1
2
3
4
5
6
7
8
public class Test {  

public static void main(String[] args) {
Provider provider = new SendMailFactory();
Sender sender = provider.produce();
sender.Send();
}
}

其实这个模式的好处就是,如果你现在想增加一个功能:发及时信息,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!
3、单例模式(Singleton)
单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。这样的模式有几个好处:
1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Singleton {  

/* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */
private static Singleton instance = null;

/* 私有构造方法,防止被实例化 */
private Singleton() {
}

/* 静态工程方法,创建实例 */
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}

/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
public Object readResolve() {
return instance;
}
}

这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,如何解决?我们首先会想到对getInstance方法加synchronized关键字,如下:

1
2
3
4
5
6
public static synchronized Singleton getInstance() {  
if (instance == null) {
instance = new Singleton();
}
return instance;
}

但是,synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以,这个地方需要改进。我们改成下面这个:

1
2
3
4
5
6
7
8
9
10
public static Singleton getInstance() {  
if (instance == null) {
synchronized (instance) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}

似乎解决了之前提到的问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为 null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的,看下面的情况:在Java指令中创建对象和赋值操作是 分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间, 然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:
a>A、B线程同时进入了第一个if判断
b>A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
c>由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。
d>B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
e>此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。
所以程序还是有可能发生错误,其实程序在运行过程是很复杂的,从这点我们就可以看出,尤其是在写多线程环境下的程序更有难度,有挑战性。我们对该程序做进一步优化:

1
2
3
4
5
6
private static class SingletonFactory{           
private static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonFactory.instance;
}

实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一 次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我 们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Singleton {  

/* 私有构造方法,防止被实例化 */
private Singleton() {
}

/* 此处使用一个内部类来维护单例 */
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}

/* 获取实例 */
public static Singleton getInstance() {
return SingletonFactory.instance;
}

/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
public Object readResolve() {
return getInstance();
}
}
```
其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选 择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建 加synchronized关键字,也是可以的:
```java
public class SingletonTest {

private static SingletonTest instance = null;

private SingletonTest() {
}

private static synchronized void syncInit() {
if (instance == null) {
instance = new SingletonTest();
}
}

public static SingletonTest getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}
}

考虑性能的话,整个程序只需创建一次实例,所以性能也不会有什么影响。
补充:采用”影子实例”的办法为单例对象的属性同步更新

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class SingletonTest {  

private static SingletonTest instance = null;
private Vector properties = null;

public Vector getProperties() {
return properties;
}

private SingletonTest() {
}

private static synchronized void syncInit() {
if (instance == null) {
instance = new SingletonTest();
}
}

public static SingletonTest getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}

public void updateProperties() {
SingletonTest shadow = new SingletonTest();
properties = shadow.getProperties();
}
}

通过单例模式的学习告诉我们:
1、单例模式理解起来简单,但是具体实现起来还是有一定的难度。
2、synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。
到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?
首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)
其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。
再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。
最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类 不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很 大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事 情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!
4、建造者模式(Builder)
工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码:
还和前面一样,一个Sender接口,两个实现类MailSender和SmsSender。最后,建造者类如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Builder {  

private List<Sender> list = new ArrayList<Sender>();

public void produceMailSender(int count){
for(int i=0; i<count; i++){
list.add(new MailSender());
}
}

public void produceSmsSender(int count){
for(int i=0; i<count; i++){
list.add(new SmsSender());
}
}
}

测试类:

1
2
3
4
5
6
7
public class Test {  

public static void main(String[] args) {
Builder builder = new Builder();
builder.produceMailSender(10);
}
}

从这点看出,建造者模式将很多功能集成到一个类里,这个类可以创造出比较复杂的东西。所以与工程模式的区别就是:工厂模式关注的是创建单个产品,而建造者模式则关注创建符合对象,多个部分。因此,是选择工厂模式还是建造者模式,依实际情况而定。
5、原型模式(Prototype)
原型模式虽然是创建型的模式,但是与工程模式没有关系,从名字即可看出,该模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。本小结会通过对象的复制,进行讲解。在Java中,复制对象是通过clone()实现的,先创建一个原型类:

1
2
3
4
5
6
7
public class Prototype implements Cloneable {  

public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
}

很简单,一个原型类,只需要实现Cloneable接口,覆写clone方法,此处clone方法可以改成任意的名称,因为Cloneable接口 是个空接口,你可以任意定义实现类的方法名,如cloneA或者cloneB,因为此处的重点是super.clone()这句 话,super.clone()调用的是Object的clone()方法,而在Object类中,clone()是native的,具体怎么实现,我会 在另一篇文章中,关于解读Java中本地方法的调用,此处不再深究。在这儿,我将结合对象的浅复制和深复制来说一下,首先需要了解对象深、浅复制的概念:
浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。
此处,写一个深浅复制的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class Prototype implements Cloneable, Serializable {  

private static final long serialVersionUID = 1L;
private String string;

private SerializableObject obj;

/* 浅复制 */
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}

/* 深复制 */
public Object deepClone() throws IOException, ClassNotFoundException {

/* 写入当前对象的二进制流 */
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);

/* 读出二进制流产生的新对象 */
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}

public String getString() {
return string;
}

public void setString(String string) {
this.string = string;
}

public SerializableObject getObj() {
return obj;
}

public void setObj(SerializableObject obj) {
this.obj = obj;
}

}

class SerializableObject implements Serializable {
private static final long serialVersionUID = 1L;
}

要实现深复制,需要采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象。
我们接着讨论设计模式,上篇文章我讲完了5种创建型模式,这章开始,我将讲下7种结构型模式:适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源,我们看下面的图:
适配器模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。首先,我们来看看类的适配器模式,先看类图:
适配器模式
核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口时Targetable,通过Adapter类,将Source的功能扩展到Targetable里,看代码:

1
2
3
4
5
6
public class Source {  

public void method1() {
System.out.println("this is original method!");
}
}

1
2
3
4
5
6
7
8
public interface Targetable {  

/* 与原类中的方法相同 */
public void method1();

/* 新类的方法 */
public void method2();
}
1
2
3
4
5
6
7
public class Adapter extends Source implements Targetable {  

@Override
public void method2() {
System.out.println("this is the targetable method!");
}
}

Adapter类继承Source类,实现Targetable接口,下面是测试类:

1
2
3
4
5
6
7
8
public class AdapterTest {  

public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

输出:
this is original method!
this is the targetable method!
这样Targetable接口的实现类就具有了Source类的功能。
对象的适配器模式
基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。看图:
适配器模式
只需要修改Adapter类的源码即可:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Wrapper implements Targetable {  

private Source source;

public Wrapper(Source source){
super();
this.source = source;
}
@Override
public void method2() {
System.out.println("this is the targetable method!");
}

@Override
public void method1() {
source.method1();
}
}

测试类:

1
2
3
4
5
6
7
8
9
public class AdapterTest {  

public static void main(String[] args) {
Source source = new Source();
Targetable target = new Wrapper(source);
target.method1();
target.method2();
}
}

输出与第一种一样,只是适配的方法不同而已。
第三种适配器模式是接口的适配器模式,接口的适配器是这样的:有时我们写的一个接口 中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些, 此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽 象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行。看一下类图:
适配器模式
这个很好理解,在实际开发中,我们也常会遇到这种接口中定义了太多的方法,以致于有时我们在一些实现类中并不是都需要。看代码:

1
2
3
4
5
public interface Sourceable {  

public void method1();
public void method2();
}

抽象类Wrapper2:

1
2
3
4
5
public abstract class Wrapper2 implements Sourceable{  

public void method1(){}
public void method2(){}
}

1
2
3
4
5
public class SourceSub1 extends Wrapper2 {  
public void method1(){
System.out.println("the sourceable interface's first Sub1!");
}
}
1
2
3
4
5
public class SourceSub2 extends Wrapper2 {  
public void method2(){
System.out.println("the sourceable interface's second Sub2!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
public class WrapperTest {  

public static void main(String[] args) {
Sourceable source1 = new SourceSub1();
Sourceable source2 = new SourceSub2();

source1.method1();
source1.method2();
source2.method1();
source2.method2();
}
}

测试输出:
the sourceable interface’s first Sub1!
the sourceable interface’s second Sub2!
达到了我们的效果!
讲了这么多,总结一下三种适配器模式的应用场景:
类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。
对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。
接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。
7、装饰模式(Decorator)
顾名思义,装饰模式就是给一个对象增加一些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个接口,装饰对象持有被装饰对象的实例,关系图如下:
装饰器模式
Source类是被装饰类,Decorator类是一个装饰类,可以为Source类动态的添加一些功能,代码如下:

1
2
3
public interface Sourceable {  
public void method();
}

1
2
3
4
5
6
7
public class Source implements Sourceable {  

@Override
public void method() {
System.out.println("the original method!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Decorator implements Sourceable {  

private Sourceable source;

public Decorator(Sourceable source){
super();
this.source = source;
}
@Override
public void method() {
System.out.println("before decorator!");
source.method();
System.out.println("after decorator!");
}
}

测试类:

1
2
3
4
5
6
7
8
public class DecoratorTest {  

public static void main(String[] args) {
Sourceable source = new Source();
Sourceable obj = new Decorator(source);
obj.method();
}
}

输出:
before decorator!
the original method!
after decorator!
装饰器模式的应用场景:
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能,而且还能动态撤销。(继承不能做到这一点,继承的功能是静态的,不能动态增删。)
缺点:产生过多相似的对象,不易排错!
8、代理模式(Proxy)
其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为 你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律 方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图:
代理模式
根据上文的阐述,代理模式就比较容易的理解了,我们看下代码:

1
2
3
public interface Sourceable {  
public void method();
}

1
2
3
4
5
6
7
public class Source implements Sourceable {  

@Override
public void method() {
System.out.println("the original method!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Proxy implements Sourceable {  

private Source source;
public Proxy(){
super();
this.source = new Source();
}
@Override
public void method() {
before();
source.method();
atfer();
}
private void atfer() {
System.out.println("after proxy!");
}
private void before() {
System.out.println("before proxy!");
}
}

测试类:

1
2
3
4
5
6
7
8
public class ProxyTest {  

public static void main(String[] args) {
Sourceable source = new Proxy();
source.method();
}

}

输出:
before proxy!
the original method!
after proxy!
代理模式的应用场景:
如果已有的方法在使用的时候需要对原有的方法进行改进,此时有两种办法:
1、修改原有的方法来适应。这样违反了“对扩展开放,对修改关闭”的原则。
2、就是采用一个代理类调用原有的方法,且对产生的结果进行控制。这种方法就是代理模式。
使用代理模式,可以将功能划分的更加清晰,有助于后期维护!
9、外观模式(Facade)
外观模式是为了解决类与类之家的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中没有涉及到接口,看下类图:(我们以一个计算机的启动过程为例)
外观模式
我们先看下实现类:

1
2
3
4
5
6
7
8
9
10
public class CPU {  

public void startup(){
System.out.println("cpu startup!");
}

public void shutdown(){
System.out.println("cpu shutdown!");
}
}

1
2
3
4
5
6
7
8
9
10
public class Memory {  

public void startup(){
System.out.println("memory startup!");
}

public void shutdown(){
System.out.println("memory shutdown!");
}
}
1
2
3
4
5
6
7
8
9
10
public class Disk {  

public void startup(){
System.out.println("disk startup!");
}

public void shutdown(){
System.out.println("disk shutdown!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Computer {  
private CPU cpu;
private Memory memory;
private Disk disk;

public Computer(){
cpu = new CPU();
memory = new Memory();
disk = new Disk();
}

public void startup(){
System.out.println("start the computer!");
cpu.startup();
memory.startup();
disk.startup();
System.out.println("start computer finished!");
}

public void shutdown(){
System.out.println("begin to close the computer!");
cpu.shutdown();
memory.shutdown();
disk.shutdown();
System.out.println("computer closed!");
}
}

User类如下:

1
2
3
4
5
6
7
8
public class User {  

public static void main(String[] args) {
Computer computer = new Computer();
computer.startup();
computer.shutdown();
}
}

输出:
start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!
如果我们没有Computer类,那么,CPU、Memory、Disk他们之间将会相互持有实例,产生关系,这样会造成严重的依赖,修改一个类, 可能会带来其他类的修改,这不是我们想要看到的,有了Computer类,他们之间的关系被放在了Computer类里,这样就起到了解耦的作用,这,就 是外观模式!
10、桥接模式(Bridge)
桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化。桥接的用意是:将抽象化与实现化解耦,使得二者可以独立变化, 像我们常用的JDBC桥DriverManager一样,JDBC进行连接数据库的时候,在各个数据库之间进行切换,基本不需要动太多的代码,甚至丝毫不 用动,原因就是JDBC提供统一接口,每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图:
桥接模式
实现代码:
先定义接口:

1
2
3
public interface Sourceable {  
public void method();
}

分别定义两个实现类:

1
2
3
4
5
6
7
public class SourceSub1 implements Sourceable {  

@Override
public void method() {
System.out.println("this is the first sub!");
}
}

1
2
3
4
5
6
7
public class SourceSub2 implements Sourceable {  

@Override
public void method() {
System.out.println("this is the second sub!");
}
}

定义一个桥,持有Sourceable的一个实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class Bridge {  
private Sourceable source;

public void method(){
source.method();
}

public Sourceable getSource() {
return source;
}

public void setSource(Sourceable source) {
this.source = source;
}
}

1
2
3
4
5
public class MyBridge extends Bridge {  
public void method(){
getSource().method();
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class BridgeTest {  

public static void main(String[] args) {

Bridge bridge = new MyBridge();

/*调用第一个对象*/
Sourceable source1 = new SourceSub1();
bridge.setSource(source1);
bridge.method();

/*调用第二个对象*/
Sourceable source2 = new SourceSub2();
bridge.setSource(source2);
bridge.method();
}
}

output:
this is the first sub!
this is the second sub!
这样,就通过对Bridge类的调用,实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图,大家就应该明白了,因为这个图是我们JDBC连接的原理,有数据库学习基础的,一结合就都懂了。
桥接模式
11、组合模式(Composite)
组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便,看看关系图:
组合模式
直接来看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class TreeNode {  

private String name;
private TreeNode parent;
private Vector<TreeNode> children = new Vector<TreeNode>();

public TreeNode(String name){
this.name = name;
}

public String getName() {
return name;
}

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

public TreeNode getParent() {
return parent;
}

public void setParent(TreeNode parent) {
this.parent = parent;
}

//添加孩子节点
public void add(TreeNode node){
children.add(node);
}

//删除孩子节点
public void remove(TreeNode node){
children.remove(node);
}

//取得孩子节点
public Enumeration<TreeNode> getChildren(){
return children.elements();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Tree {  

TreeNode root = null;

public Tree(String name) {
root = new TreeNode(name);
}

public static void main(String[] args) {
Tree tree = new Tree("A");
TreeNode nodeB = new TreeNode("B");
TreeNode nodeC = new TreeNode("C");

nodeB.add(nodeC);
tree.root.add(nodeB);
System.out.println("build the tree finished!");
}
}

使用场景:将多个对象组合在一起进行操作,常用于表示树形结构中,例如二叉树,数等。
12、享元模式(Flyweight)
享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。
享元模式
FlyWeightFactory负责创建和管理享元单元,当一个客户端请求时,工厂需要检查当前对象池中是否有符合条件的对象,如果有,就返回已 经存在的对象,如果没有,则创建一个新对象,FlyWeight是超类。一提到共享池,我们很容易联想到Java里面的JDBC连接池,想想每个连接的特 点,我们不难总结出:适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接池来说,url、driverClassName、 username、password及dbname,这些属性对于每个连接来说都是一样的,所以就适合用享元模式来处理,建一个工厂类,将上述类似属性作 为内部数据,其它的作为外部数据,在方法调用时,当做参数传进来,这样就节省了空间,减少了实例的数量。
看个例子:
享元模式
看下数据库连接池的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class ConnectionPool {  

private Vector<Connection> pool;

/*公有属性*/
private String url = "jdbc:mysql://localhost:3306/test";
private String username = "root";
private String password = "root";
private String driverClassName = "com.mysql.jdbc.Driver";

private int poolSize = 100;
private static ConnectionPool instance = null;
Connection conn = null;

/*构造方法,做一些初始化工作*/
private ConnectionPool() {
pool = new Vector<Connection>(poolSize);

for (int i = 0; i < poolSize; i++) {
try {
Class.forName(driverClassName);
conn = DriverManager.getConnection(url, username, password);
pool.add(conn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/* 返回连接到连接池 */
public synchronized void release() {
pool.add(conn);
}

/* 返回连接池中的一个数据库连接 */
public synchronized Connection getConnection() {
if (pool.size() > 0) {
Connection conn = pool.get(0);
pool.remove(conn);
return conn;
} else {
return null;
}
}
}

通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能!本章讲解了7种结构型模式,因为篇幅的问题,剩下的11种行为型模式,
本章是关于设计模式的最后一讲,会讲到第三种设计模式——行为型模式,共11种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命 令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。这段时间一直在写关于设计模式的东西,终于写到一半了,写博文是个很费时间的东西, 因为我得为读者负责,不论是图还是代码还是表述,都希望能尽量写清楚,以便读者理解,我想不论是我还是读者,都希望看到高质量的博文出来,从我本人出发, 我会一直坚持下去,不断更新,源源动力来自于读者朋友们的不断支持,我会尽自己的努力,写好每一篇文章!希望大家能不断给出意见和建议,共同打造完美的博 文!

先来张图,看看这11中模式的关系:
第一类:通过父类与子类的关系进行实现。第二类:两个类之间。第三类:类的状态。第四类:通过中间类
模式关系
13、策略模式(strategy)
策略模式定义了一系列算法,并将每个算法封装起来,使他们可以相互替换,且算法的变化不会影响到使用算法的客户。需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口,设计一个抽象类(可有可无,属于辅助类),提供辅助函数,关系图如下:
策略模式
图中ICalculator提供同意的方法,
AbstractCalculator是辅助类,提供辅助方法,接下来,依次实现下每个类:
首先统一接口:

1
2
3
public interface ICalculator {  
public int calculate(String exp);
}

辅助类:

1
2
3
4
5
6
7
8
9
10
public abstract class AbstractCalculator {  

public int[] split(String exp,String opt){
String array[] = exp.split(opt);
int arrayInt[] = new int[2];
arrayInt[0] = Integer.parseInt(array[0]);
arrayInt[1] = Integer.parseInt(array[1]);
return arrayInt;
}
}

三个实现类:

1
2
3
4
5
6
7
8
public class Plus extends AbstractCalculator implements ICalculator {  

@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"\\+");
return arrayInt[0]+arrayInt[1];
}
}

1
2
3
4
5
6
7
8
9
public class Minus extends AbstractCalculator implements ICalculator {  

@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"-");
return arrayInt[0]-arrayInt[1];
}

}
1
2
3
4
5
6
7
8
public class Multiply extends AbstractCalculator implements ICalculator {  

@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"\\*");
return arrayInt[0]*arrayInt[1];
}
}

简单的测试类:

1
2
3
4
5
6
7
8
9
public class StrategyTest {  

public static void main(String[] args) {
String exp = "2+8";
ICalculator cal = new Plus();
int result = cal.calculate(exp);
System.out.println(result);
}
}

输出:10
策略模式的决定权在用户,系统本身提供不同算法的实现,新增或者删除算法,对各种算法做封装。因此,策略模式多用在算法决策系统中,外部用户只需要决定用哪个算法即可。
14、模板方法模式(Template Method)
解释一下模板方法模式,就是指:一个抽象类中,有一个主方法,再定义1…n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用,先看个关系图:
模板模式
就是在AbstractCalculator类中定义一个主方法calculate,calculate()调用spilt()等,Plus和 Minus分别继承AbstractCalculator类,通过对AbstractCalculator的调用实现对子类的调用,看下面的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public abstract class AbstractCalculator {  

/*主方法,实现对本类其它方法的调用*/
public final int calculate(String exp,String opt){
int array[] = split(exp,opt);
return calculate(array[0],array[1]);
}

/*被子类重写的方法*/
abstract public int calculate(int num1,int num2);

public int[] split(String exp,String opt){
String array[] = exp.split(opt);
int arrayInt[] = new int[2];
arrayInt[0] = Integer.parseInt(array[0]);
arrayInt[1] = Integer.parseInt(array[1]);
return arrayInt;
}
}

1
2
3
4
5
6
7
public class Plus extends AbstractCalculator {  

@Override
public int calculate(int num1,int num2) {
return num1 + num2;
}
}

测试类:

1
2
3
4
5
6
7
8
9
public class StrategyTest {  

public static void main(String[] args) {
String exp = "8+8";
AbstractCalculator cal = new Plus();
int result = cal.calculate(exp, "\\+");
System.out.println(result);
}
}

我跟踪下这个小程序的执行过程:首先将exp和”\+”做参数,调用AbstractCalculator类里的 calculate(String,String)方法,在calculate(String,String)里调用同类的split(),之后再调用 calculate(int ,int)方法,从这个方法进入到子类中,执行完return num1 + num2后,将值返回到AbstractCalculator类,赋给result,打印出来。正好验证了我们开头的思路。
15、观察者模式(Observer)
包括这个模式在内的接下来的四个模式,都是类和类之间的关系,不涉及到继承,学的时候应该 记得归纳,记得本文最开始的那个图。观察者模式很好理解,类似于邮件订阅和RSS订阅,当我们浏览一些博客或wiki时,经常会看到RSS图标,就这的意 思是,当你订阅了该文章,如果后续有更新,会及时通知你。其实,简单来讲就一句话:当一个对象变化时,其它依赖该对象的对象都会收到通知,并且随着变化! 对象之间是一种一对多的关系。先来看看关系图:
观察者模式
我解释下这些类的作用:MySubject类就是我们的主对象,Observer1和Observer2是依赖于MySubject的对象,当 MySubject变化时,Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表,可以对其进 行修改:增加或删除被监控对象,且当MySubject变化时,负责通知在列表内存在的对象。我们看实现代码:
一个Observer接口:

1
2
3
public interface Observer {  
public void update();
}

两个实现类:

1
2
3
4
5
6
7
public class Observer1 implements Observer {  

@Override
public void update() {
System.out.println("observer1 has received!");
}
}

1
2
3
4
5
6
7
8
public class Observer2 implements Observer {  

@Override
public void update() {
System.out.println("observer2 has received!");
}

}

Subject接口及实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface Subject {  

/*增加观察者*/
public void add(Observer observer);

/*删除观察者*/
public void del(Observer observer);

/*通知所有的观察者*/
public void notifyObservers();

/*自身的操作*/
public void operation();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public abstract class AbstractSubject implements Subject {  

private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}

@Override
public void del(Observer observer) {
vector.remove(observer);
}

@Override
public void notifyObservers() {
Enumeration<Observer> enumo = vector.elements();
while(enumo.hasMoreElements()){
enumo.nextElement().update();
}
}
}
1
2
3
4
5
6
7
8
9
public class MySubject extends AbstractSubject {  

@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}

}

测试类:

1
2
3
4
5
6
7
8
9
10
11
public class ObserverTest {  

public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());

sub.operation();
}

}

输出:
update self!
observer1 has received!
observer2 has received!
这些东西,其实不难,只是有些抽象,不太容易整体理解,建议读者:根据关系图,新建项目,自己写代码(或者参考我的代码),按照总体思路走一遍,这样才能体会它的思想,理解起来容易!
16、迭代子模式(Iterator)
顾名思义,迭代器模式就是顺序访问聚集中的对象,一般来说,集合中非常常见,如果对集合类比较熟悉的话,理解本模式会十分轻松。这句话包含两层意思:一是需要遍历的对象,即聚集对象,二是迭代器对象,用于对聚集对象进行遍历访问。我们看下关系图:
迭代模式
这个思路和我们常用的一模一样,MyCollection中定义了集合的一些操作,MyIterator中定义了一系列迭代操作,且持有Collection实例,我们来看看实现代码:
两个接口:

1
2
3
4
5
6
7
8
9
10
public interface Collection {  

public Iterator iterator();

/*取得集合元素*/
public Object get(int i);

/*取得集合大小*/
public int size();
}

1
2
3
4
5
6
7
8
9
10
11
public interface Iterator {  
//前移
public Object previous();

//后移
public Object next();
public boolean hasNext();

//取得第一个元素
public Object first();
}

两个实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MyCollection implements Collection {  

public String string[] = {"A","B","C","D","E"};
@Override
public Iterator iterator() {
return new MyIterator(this);
}

@Override
public Object get(int i) {
return string[i];
}

@Override
public int size() {
return string.length;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class MyIterator implements Iterator {  

private Collection collection;
private int pos = -1;

public MyIterator(Collection collection){
this.collection = collection;
}

@Override
public Object previous() {
if(pos > 0){
pos--;
}
return collection.get(pos);
}

@Override
public Object next() {
if(pos<collection.size()-1){
pos++;
}
return collection.get(pos);
}

@Override
public boolean hasNext() {
if(pos<collection.size()-1){
return true;
}else{
return false;
}
}

@Override
public Object first() {
pos = 0;
return collection.get(pos);
}

}

测试类:

1
2
3
4
5
6
7
8
9
10
11
public class Test {  

public static void main(String[] args) {
Collection collection = new MyCollection();
Iterator it = collection.iterator();

while(it.hasNext()){
System.out.println(it.next());
}
}
}

输出:A B C D E
此处我们貌似模拟了一个集合类的过程,感觉是不是很爽?其实JDK中各个类也都是这些基本的东西,加一些设计模式,再加一些优化放到一起的,只要我们把这些东西学会了,掌握好了,我们也可以写出自己的集合类,甚至框架!
17、责任链模式(Chain of Responsibility)
接下 来我们将要谈谈责任链模式,有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。但是发 出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。先看看关系图:
链式责任模式

Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。

1
2
3
public interface Handler {  
public void operator();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class AbstractHandler {  

private Handler handler;

public Handler getHandler() {
return handler;
}

public void setHandler(Handler handler) {
this.handler = handler;
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MyHandler extends AbstractHandler implements Handler {  

private String name;

public MyHandler(String name) {
this.name = name;
}

@Override
public void operator() {
System.out.println(name+"deal!");
if(getHandler()!=null){
getHandler().operator();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {  

public static void main(String[] args) {
MyHandler h1 = new MyHandler("h1");
MyHandler h2 = new MyHandler("h2");
MyHandler h3 = new MyHandler("h3");

h1.setHandler(h2);
h2.setHandler(h3);

h1.operator();
}
}

输出:
h1deal!
h2deal!
h3deal!
此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。
18、命令模式(Command)
命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里, 士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。 我们看看关系图:
命令模式
Invoker是调用者(司令员),Receiver是被调用者(士兵),MyCommand是命令,实现了Command接口,持有接收对象,看实现代码:

1
2
3
public interface Command {  
public void exe();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyCommand implements Command {  

private Receiver receiver;

public MyCommand(Receiver receiver) {
this.receiver = receiver;
}

@Override
public void exe() {
receiver.action();
}
}
1
2
3
4
5
public class Receiver {  
public void action(){
System.out.println("command received!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
public class Invoker {  

private Command command;

public Invoker(Command command) {
this.command = command;
}

public void action(){
command.exe();
}
}
1
2
3
4
5
6
7
8
9
public class Test {  

public static void main(String[] args) {
Receiver receiver = new Receiver();
Command cmd = new MyCommand(receiver);
Invoker invoker = new Invoker(cmd);
invoker.action();
}
}

输出:command received!
这个很哈理解,命令模式的目的就是达到命令的发出者和执行者之间解耦,实现请求和执行分开,熟悉Struts的同学应该知道,Struts其实就是一种将请求和呈现分离的技术,其中必然涉及命令模式的思想!
其实每个设计模式都是很重要的一种思想,看上去很熟,其实是因为我们在学到的东西中都有涉及,尽管有时我们并不知道,其实在Java本身的设计之中 处处都有体现,像AWT、JDBC、集合类、IO管道或者是Web框架,里面设计模式无处不在。因为我们篇幅有限,很难讲每一个设计模式都讲的很详细,不 过我会尽我所能,尽量在有限的空间和篇幅内,把意思写清楚了,更好让大家明白。本章不出意外的话,应该是设计模式最后一讲了,首先还是上一下上篇开头的那 个图:

本章讲讲第三类和第四类。
19、备忘录模式(Memento)
主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类A,A中有各种属性,A可以 决定需要备份的属性,备忘录类B是用来存储A的一些内部状态,类C呢,就是一个用来存储备忘录的,且只能存储,不能修改等操作。做个图来分析一下:
备忘录模式
Original类是原始类,里面有需要保存的属性value及创建一个备忘录类,用来保存value值。Memento类是备忘录类,Storage类是存储备忘录的类,持有Memento类的实例,该模式很好理解。直接看源码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Original {  

private String value;

public String getValue() {
return value;
}

public void setValue(String value) {
this.value = value;
}

public Original(String value) {
this.value = value;
}

public Memento createMemento(){
return new Memento(value);
}

public void restoreMemento(Memento memento){
this.value = memento.getValue();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Memento {  

private String value;

public Memento(String value) {
this.value = value;
}

public String getValue() {
return value;
}

public void setValue(String value) {
this.value = value;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Storage {  

private Memento memento;

public Storage(Memento memento) {
this.memento = memento;
}

public Memento getMemento() {
return memento;
}

public void setMemento(Memento memento) {
this.memento = memento;
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Test {  

public static void main(String[] args) {

// 创建原始类
Original origi = new Original("egg");

// 创建备忘录
Storage storage = new Storage(origi.createMemento());

// 修改原始类的状态
System.out.println("初始化状态为:" + origi.getValue());
origi.setValue("niu");
System.out.println("修改后的状态为:" + origi.getValue());

// 回复原始类的状态
origi.restoreMemento(storage.getMemento());
System.out.println("恢复后的状态为:" + origi.getValue());
}
}

输出:
初始化状态为:egg
修改后的状态为:niu
恢复后的状态为:egg
简单描述下:新建原始类时,value被初始化为egg,后经过修改,将value的值置为niu,最后倒数第二行进行恢复状态,结果成功恢复了。其实我觉得这个模式叫“备份-恢复”模式最形象。
20、状态模式(State)
核心思想就是:当对象的状态改变时,同时改变其行为,很好理解!就拿QQ来说,有几种状态,在线、隐身、忙碌等,每个状态对应不同的操作,而且你的 好友也能看到你的状态,所以,状态模式就两点:1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。看图:
状态模式
State类是个状态类,Context类可以实现切换,我们来看看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.xtfggef.dp.state;  

/**
* 状态类的核心类
* 2012-12-1
* @author erqing
*
*/
public class State {

private String value;

public String getValue() {
return value;
}

public void setValue(String value) {
this.value = value;
}

public void method1(){
System.out.println("execute the first opt!");
}

public void method2(){
System.out.println("execute the second opt!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.xtfggef.dp.state;  

/**
* 状态模式的切换类 2012-12-1
* @author erqing
*
*/
public class Context {

private State state;

public Context(State state) {
this.state = state;
}

public State getState() {
return state;
}

public void setState(State state) {
this.state = state;
}

public void method() {
if (state.getValue().equals("state1")) {
state.method1();
} else if (state.getValue().equals("state2")) {
state.method2();
}
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {  

public static void main(String[] args) {

State state = new State();
Context context = new Context(state);

//设置第一种状态
state.setValue("state1");
context.method();

//设置第二种状态
state.setValue("state2");
context.method();
}
}

输出:

execute the first opt!
execute the second opt!
根据这个特性,状态模式在日常开发中用的挺多的,尤其是做网站的时候,我们有时希望根据对象的某一属性,区别开他们的一些功能,比如说简单的权限控制等。
21、访问者模式(Visitor)
访问者模式把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问 者模式使得算法操作增加变得容易。若系统数据结构对象易于变化,经常有新的数据对象增加进来,则不适合使用访问者模式。访问者模式的优点是增加操作很容 易,因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中,其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。 —— From 百科
简单来说,访问者模式就是一种分离对象数据结构与行为的方法,通过这种分离,可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。简单关系图:
访问者模式
来看看原码:一个Visitor类,存放要访问的对象,

1
2
3
public interface Visitor {  
public void visit(Subject sub);
}
1
2
3
4
5
6
7
public class MyVisitor implements Visitor {  

@Override
public void visit(Subject sub) {
System.out.println("visit the subject:"+sub.getSubject());
}
}

Subject类,accept方法,接受将要访问它的对象,getSubject()获取将要被访问的属性,

1
2
3
4
public interface Subject {  
public void accept(Visitor visitor);
public String getSubject();
}

1
2
3
4
5
6
7
8
9
10
11
12
public class MySubject implements Subject {  

@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}

@Override
public String getSubject() {
return "love";
}
}

测试:

1
2
3
4
5
6
7
8
9
public class Test {  

public static void main(String[] args) {

Visitor visitor = new MyVisitor();
Subject sub = new MySubject();
sub.accept(visitor);
}
}

输出:visit the subject:love

该模式适用场景:如果我们想为一个现有的类增加新功能,不得不考虑几个事情:1、新功能会不会与现有功能出现兼容性问题?2、以后会不会再需要添 加?3、如果类不允许修改代码怎么办?面对这些问题,最好的解决方法就是使用访问者模式,访问者模式适用于数据结构相对稳定的系统,把数据结构和算法解 耦,
22、中介者模式(Mediator)
中介者模式也是用来降低类类之间的耦合的,因为如果类类之间有依赖关系的话,不利于功能的拓展和维护,因为只要修改一个对象,其它关联的对象都得进 行修改。如果使用中介者模式,只需关心和Mediator类的关系,具体类类之间的关系及调度交给Mediator就行,这有点像spring容器的作 用。先看看图:
中介模式
User类统一接口,User1和User2分别是不同的对象,二者之间有关联,如果不采用中介者模式,则需要二者相互持有引用,这样二者的耦合度 很高,为了解耦,引入了Mediator类,提供统一接口,MyMediator为其实现类,里面持有User1和User2的实例,用来实现对 User1和User2的控制。这样User1和User2两个对象相互独立,他们只需要保持好和Mediator之间的关系就行,剩下的全由 MyMediator类来维护!基本实现:

1
2
3
4
public interface Mediator {  
public void createMediator();
public void workAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MyMediator implements Mediator {  

private User user1;
private User user2;

public User getUser1() {
return user1;
}

public User getUser2() {
return user2;
}

@Override
public void createMediator() {
user1 = new User1(this);
user2 = new User2(this);
}

@Override
public void workAll() {
user1.work();
user2.work();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class User {  

private Mediator mediator;

public Mediator getMediator(){
return mediator;
}

public User(Mediator mediator) {
this.mediator = mediator;
}

public abstract void work();
}
1
2
3
4
5
6
7
8
9
10
11
public class User1 extends User {  

public User1(Mediator mediator){
super(mediator);
}

@Override
public void work() {
System.out.println("user1 exe!");
}
}
1
2
3
4
5
6
7
8
9
10
11
public class User2 extends User {  

public User2(Mediator mediator){
super(mediator);
}

@Override
public void work() {
System.out.println("user2 exe!");
}
}

测试类:

1
2
3
4
5
6
7
8
public class Test {  

public static void main(String[] args) {
Mediator mediator = new MyMediator();
mediator.createMediator();
mediator.workAll();
}
}

输出:

user1 exe!
user2 exe!
23、解释器模式(Interpreter)
解释器模式是我们暂时的最后一讲,一般主要应用在OOP开发中的编译器的开发中,所以适用面比较窄。
解释器模式
Context类是一个上下文环境类,Plus和Minus分别是用来计算的实现,代码如下:

1
2
3
public interface Expression {  
public int interpret(Context context);
}
1
2
3
4
5
6
7
public class Plus implements Expression {  

@Override
public int interpret(Context context) {
return context.getNum1()+context.getNum2();
}
}
1
2
3
4
5
6
7
public class Minus implements Expression {  

@Override
public int interpret(Context context) {
return context.getNum1()-context.getNum2();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Context {  

private int num1;
private int num2;

public Context(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}

public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}


}
```java
public class Test {

public static void main(String[] args) {

// 计算9+2-8的值
int result = new Minus().interpret((new Context(new Plus()
.interpret(new Context(9, 2)), 8)));
System.out.println(result);
}
}

最后输出正确的结果:3。

基本就这样,解释器模式用来做各种各样的解释器,如正则表达式等的解释器等等!

分享到