Java装饰模式

liyang — Sun, 01 Nov 2009 02:38:00 GMT

说明：

装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的特点；

（1）装饰对象和真实对象有相同的接口。这样客户端对象就可以以和真实对象相同的方式和装饰对象交互。
（2）装饰对象包含一个真实对象的索引（reference）
（3）装饰对象接受所有的来自客户端的请求。它把这些请求转发给真实的对象。
（4）装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。

装饰模式 VS 继承

装饰模式                                                                 继承
用来扩展特定对象的功能                     用来扩展一类对象的功能
不需要子类                                             需要子类
动态地                                                     静态地
运行时分配职责                                     编译时分派职责
防止由于子类而导致的复杂和混乱     导致很多子类产生，在一些场合，报漏类的层次
更多的灵活性                                         缺乏灵活性

例子：

让我们重新返回我们在工厂方法和单例模式log实用工具上，我们的模式主要由Logger 接口和两个它的实现类??FileLogger和ConsoleLogger??分别把信息出力到一个文件和屏幕中。另外，还有包括工厂方法的LoggerFactory类。
LoggerFactory没有出现在下图中，主要是因为它和现在讨论的例子没有直接联系。

让我们想象一些客户端需要以超出Logger Utility现在所提供的新的方式出力信息，客户端需要下面两种特征；
（1）把出力的信息传唤为HTML文档
（2）对出力信息进行逻辑转化的简单加密，在面向对象的设计中，不改变现存的类的代码，可以应用继承来增加新的功能。例如，子类化现在的类重载它的方法来增加所需要的新功能。

应用继承，我们要子类化FileLogger和ConsoleLogger类来增加新的功能，会有下面的一组新的子类：
子类父类功能
HTMLFileLogger FileLogger 转化出力信息为HTML文档，并存入一个Log文件
HTMLConsLogger ConsoleLogger 转化出力信息为HTML文档，并显示在屏幕上
EncFileLogger FileLogger 加密出力信息，并存入一个Log文件
EncConsLogger ConsoleLogger 加密出力信息，并显示在屏幕上

从类图可以看到，为了实现新的功能加入了一组新的子类。如果我们还有其他的Logger类型（例如：DBLogger出力信息到数据库中），这样会有更多子类。当一个新的特性需要被加入，子类的数量会有成倍数的增长，同时我们会有一个庞大的类层次。

装饰模式使我们从这种情景中解脱出来，装饰模式推荐通过对象的合成而不是继承来包装一个对象扩展它的功能。
应用装饰模式，让我们为Logger Utility定义一个有下列特征的默认根装饰类LoggerDecorator：

（1） LoggerDecorator包括一个Logger实例的引用。这个引用指向它包含的Logger对象。
（2） LoggerDecorator实现Logger借口、提供Log方法的基本的默认实现，他只是简单的转发调用给它包含的Logger 对象。每一个LoggerDecorator子类保证定义log方法。

Listing 19.1: LoggerDecorator Class

public class LoggerDecorator implements Logger {
Logger logger;
public LoggerDecorator(Logger inp_logger) {
logger = inp_logger;
}
public void log(String DataLine) {
/*
Default implementation
to be overriden by subclasses.
*/
logger.log(DataLine);
}
}//end of class

每一个logger的装饰定义log方法使很重要的，因为装饰对象必须提供和它包装的对象相同的借口。当客户端创建一个装饰类的实例，客户端以与装饰类交互方式和客户端与拥有相同接口原对象的交互方式是一致的。
让我们定义LoggerDecorator的两个子类，HTMLLogger和EncryptLogger。 #p# 具体的Logger 装饰类

HTMLLogger

HTMLLogger重载了log方法的默认实现。在log方法中，装饰类把出力信息转化为HTML文档，并且发送给可以出力的Logger实例。
Listing 19.2: HTMLLogger Class

public class HTMLLogger extends LoggerDecorator {
public HTMLLogger(Logger inp_logger) {
super(inp_logger);
}
public void log(String DataLine) {
/*
Added functionality
*/
DataLine = makeHTML(DataLine);
/*
Now forward the encrypted text to the FileLogger
for storage
*/
logger.log(DataLine);
}
public String makeHTML(String DataLine) {
/*
Make it into an HTML document.
*/
DataLine = "" + """ + DataLine +
" + "";
return DataLine;
}
}//end of class

EncryptLogger

与HTMLLogger相似，EncryptLogger重载了log方法，在log方法中，EncryptLogger通过简单的将字符位置向右转移一位实现了加密逻辑，并且发送给可以出力的Logger实例。

Listing 19.3: EncryptLogger Class

public class EncryptLogger extends LoggerDecorator {
public EncryptLogger(Logger inp_logger) {
super(inp_logger);
}
public void log(String DataLine) {
/*
Added functionality
*/
DataLine = encrypt(DataLine);
/*
Now forward the encrypted text to the FileLogger
for storage
*/
logger.log(DataLine);
}
public String encrypt(String DataLine) {
/*
Apply simple encryption by Transposition…
Shift all characters by one position.
*/
DataLine = DataLine.substring(DataLine.length() − 1) +
DataLine.substring(0, DataLine.length() − 1);
return DataLine;
}
}//end of class

为了使用新设计装饰对象，客户端需要：

（1）使用LoggerFactory工厂方法创建一个合适的Logger实例（FileLogger/ConsoleLogger）。
（2）把第一步中创建的Logger实例作为参数转递给新创建的合适的LoggerDecorator实例的构造函数。
（3）调用LoggerDecorator实例上的方法，

Listing 19.4: Client DecoratorClient Class

class DecoratorClient {
public static void main(String[] args) {
LoggerFactory factory = new LoggerFactory();
Logger logger = factory.getLogger();
HTMLLogger hLogger = new HTMLLogger(logger);
//the decorator object provides the same interface.
hLogger.log("A Message to Log");
EncryptLogger eLogger = new EncryptLogger(logger);
eLogger.log("A Message to Log");
}
}//End of class

增加新的信息出力类型

在Logging Utility实例中，应用装饰模式对比使用继承不会因为类层次的增长而导致大量的子类，我们还有另外的Logger类型：DBLogger??出力信息到数据库中。为了将信息转化HTML格式或在出力到数据库以前对信息进行加密，客户端只需遵从上面提到的步骤，因为DBLogger是一种Logger类型，它可以作为构造函数的参数传递给HTMLLogger或EncryptLogger中任何一个类。

增加新的装饰

从例子中可以看到，LoggerDecorator实例包含了一个Logger类型了对象实例，在转发请求给Logger对象实例以前或以后，增加新的功能。因为LoggerDecorator类实现了Logger接口，LoggerDecorator实例或它的任何一个子类都可以作为一个Logger类型。因此LoggerDecortator包含它的任何子类的一个实例，并且将请求转发给它/。一般的一个装饰对象可以包含另一个装饰对象，并且可以向它转发请求。通过这种方式，新的装饰类，新的功能可以通过包装现存的装饰类来实现。

liyang 2009-11-01 10:38 发表评论

单例模式完全剖析

liyang — Mon, 26 Oct 2009 08:58:00 GMT

摘要: 概要单例模式是最简单的设计模式之一，但是对于Java的开发者来说，它却有很多缺陷。在本月的专栏中，David Geary探讨了单例模式以及在面对多线程（multithreading)、类装载器（classloaders）和序列化(serialization)时如何处理这些缺陷。单例模式适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统，它们都是... 阅读全文

liyang 2009-10-26 16:58 发表评论

java动态代理实例

liyang — Sat, 24 Oct 2009 13:44:00 GMT

1.真实对象接口

1 public interface IAnimal {
2 void info();
3 }

2.真实类

1 public class Cat implements IAnimal{
2
3     public void info() {
4         System.out.println("This is a cat!");
5     }
6
7 }

3.调用处理器

1 import java.lang.reflect.InvocationHandler;
2 import java.lang.reflect.Method;
3
4 public class TraceHandler implements InvocationHandler{
5
6     private Object target;//以真实角色作为代理角色的属性
7
8     //构造器
9     public TraceHandler(Object target) {
10         this.target = target;
11     }
12
13     /*
14      * 通过反射机制动态执行真实角色的每一个方法
15      */
16     public Object invoke(Object proxy, Method method, Object[] args)
17             throws Throwable {
18         try {
19             System.out.println("被拦截的方法:" + method.getName());
20             System.out.println("预处理.");
21
22             return method.invoke(target, args);//调用真是对象的method方法
23
24         } catch (Exception e) {
25             return null;
26         } finally {
27              System.out.println("善后处理.");
28         }
29     }
30 }

4.客户端

1 import java.lang.reflect.InvocationHandler;
2 import java.lang.reflect.Proxy;
3
4 public class ProxyTest {
5     public static void main(String[] args) {
6
7         //真实对象（即被代理对象）
8         final IAnimal animal = new Cat();
9
10         //为真实对象制定一个调用处理器
11         InvocationHandler handler = new TraceHandler(animal);
12
13         //获得真实对象(animal)的一个代理类 ★★★★★
14         Object proxyObj = Proxy.newProxyInstance(
15                 animal.getClass().getClassLoader(), //真实对象的类加载器
16                 animal.getClass().getInterfaces(),  //真实对象实现的所有接口
17                 handler                                //真实对象的处理器
18                 );
19
20          if (proxyObj instanceof IAnimal) {
21             System.out.println("the proxyObj is an animal!");
22
23             IAnimal animalProxy = (IAnimal)proxyObj;//proxyObj与animal都实现了IAnimal接口
24
25             animalProxy.info();//像普通animal对象一样使用(通过handler的invoke方法执行)
26         } else {
27             System.out.println("the proxyObj isn't an animal!");
28         }
29     }
30 }

liyang 2009-10-24 21:44 发表评论

JAVA代理模式

liyang — Sat, 24 Oct 2009 12:54:00 GMT

摘要: 代理模式代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。代理模式一般涉及到的角色有：抽象角色：声明真实对象和代理对象的共同接口；代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实... 阅读全文

liyang 2009-10-24 20:54 发表评论

BlogJava-thisliy-随笔分类-design pattern