设计模式实战6--结构型--装饰模式

装饰模式（Decorator）定义：动态地给一个对象添加一些额外的职责。就扩展功能而言， 它比生成子类方式更为灵活。

装饰模式结构图：

装饰模式解析:

Component：
组件对象的接口，可以给这些对象动态的添加职责。
ConcreteComponent：
具体的组件对象，实现组件对象接口，通常就是被装饰器装饰的原始对象，也就是可以给这个对象添加职责。
Decorator：
所有装饰器的抽象父类，需要定义一个与组件接口一致的接口，并持有一个Component对象，其实就是持有一个被装饰的对象。
注意这个被装饰的对象不一定是最原始的那个对象了，也可能是被其它装饰器装饰过后的对象，反正都是实现的同一个接口，也就是同一类型。
ConcreteDecorator：
实际的装饰器对象，实现具体要向被装饰对象添加的功能。

装饰模式实战：

包的结构图如下：

源码如下：

-------------------------------模仿Servlet规范，定义接口----------------------------------------

package org.leiwen.dp.structure.decorator.request;

public interface Filter {

// public abstract void init(javax.servlet.FilterConfig fiterConfig);

// 简化处理
public abstract void init();

void doFilter(HttpServletRequest req, HttpServletResponse res,FilterChain chain);

public abstract void destroy();
}

package org.leiwen.dp.structure.decorator.request;

//过滤器链
public interface FilterChain {

void doFilter(HttpServletRequest req, HttpServletResponse res);

}

package org.leiwen.dp.structure.decorator.request;

public interface HttpServletRequest {

public Object getAttribute(String name);

public void setAttribute(String name, Object value);
}

package org.leiwen.dp.structure.decorator.request;

public interface HttpServletResponse {

// 什么也没有，只是演示而已.我是打酱油的。
}

--------------------------------接口的实现类--------------------------------------------------------------------

package org.leiwen.dp.structure.decorator.request.impl;

import org.leiwen.dp.structure.decorator.request.HttpServletResponse;

public class HttpServletResponseImpl implements HttpServletResponse {

// 什么也没有，只是演示而已.我是打酱油的。
}

package org.leiwen.dp.structure.decorator.request.impl;

import org.leiwen.dp.structure.decorator.request.FilterChain;
import org.leiwen.dp.structure.decorator.request.HttpServletRequest;
import org.leiwen.dp.structure.decorator.request.HttpServletResponse;

public class FilterChainImpl implements FilterChain {

@Override
public void doFilter(HttpServletRequest req, HttpServletResponse res) {

// 什么也没有，只是演示而已.我是打酱油的。
}

}

package org.leiwen.dp.structure.decorator.request.impl;

import java.util.HashMap;
import java.util.Map;

import org.leiwen.dp.structure.decorator.request.HttpServletRequest;

public class HttpServletRequestImpl implements HttpServletRequest {

private Map<String, Object> context = new HashMap<String, Object>();

@Override
public Object getAttribute(String name) {
return context.get(name);
}

@Override
public void setAttribute(String name, Object value) {
context.put(name, value);
}

}

package org.leiwen.dp.structure.decorator.request.impl;

import org.leiwen.dp.structure.decorator.request.Filter;
import org.leiwen.dp.structure.decorator.request.FilterChain;
import org.leiwen.dp.structure.decorator.request.HttpServletRequest;
import org.leiwen.dp.structure.decorator.request.HttpServletResponse;
import org.leiwen.dp.structure.decorator.request.decorator.CacheManager;
import org.leiwen.dp.structure.decorator.request.decorator.HttpServletRequestWrapper;

/**
* 最初，我误解了Struts2技术内幕上的这个例子。
*
* 书中的例子，即本代码，想要表明的是：变量如果以CACHE_PREFIX为前缀，就从缓存中读取数据， 否则就从request中读取数据。
*
* 即request只是增加了了“从缓存中读取数据”的新特性。
*
* 误解--注意：在缓存存在的情况下，我们通常优先从缓存中读取数据，缓存中没有的话再从其它地方读取数据。然而，这不是本例实现的功能。
* 如果需要实现这个功能，有几个地方需要变更，但是仍然可以使用装饰模式实现。
*/
public class DecoratorSampleFilter implements Filter {

public void doFilter(HttpServletRequest req, HttpServletResponse res,
FilterChain chain) {

// 对request进行装饰，增加功能
HttpServletRequest request = new HttpServletRequestWrapper(req);

// 从缓存中获取数据
Object cachefans = request.getAttribute(CacheManager.CACHE_PREFIX
+ "fans");
Object decorator = request.getAttribute(CacheManager.CACHE_PREFIX
+ "decorator");
Object softfans = request.getAttribute(CacheManager.CACHE_PREFIX
+ "softfans");
// 从reqest中的获取数据
Object fans = request.getAttribute("fans");
Object leiwen = request.getAttribute("leiwen");

//打印数据
println("以下是从缓存中获取到的数据：");
println("cache fans=" + cachefans);
println("decorator=" + decorator);
println("softfans=" + softfans);
println("");
println("以下是直接从request中获取到的数据：");
println("fans=" + fans);
println("leiwen=" + leiwen);

chain.doFilter(req, res);
}

@Override
public void init() {
// 什么也没有，只是演示而已.
}

@Override
public void destroy() {
// 什么也没有，只是演示而已.
}

// 简单的工具方法，打印对象
public static void println(Object content) {
System.out.println(content);
}
}

-----------------------------------------装饰类--增加的功能-------------------------------------------------------

package org.leiwen.dp.structure.decorator.request.decorator;

import java.util.HashMap;
import java.util.Map;

/**
* 缓存管理器，这个类只是简单地抽象了缓存管理的部分方法，缓存管理的具体完整实现可以自行实现。
*/
public class CacheManager {

private Map<String, Object> caches = new HashMap<String, Object>();

public static final String CACHE_PREFIX = "cache.";

// 故意向缓存中增加一些数据,实际应用中可以采取其它方式
{
caches.put("fans", "I am a fans of cache!");
caches.put("decorator", "Decorator Pattern");
caches.put("softfans", "软林至尊，Fans同盟。号令天下，莫敢不从。");
}

// 向缓存中存储对象
public void setValue(String name, Object obj) {
caches.put(name, obj);
}

// 从缓存中获取对象
public Object getValue(String name) {
return caches.get(name);
}

}

package org.leiwen.dp.structure.decorator.request.decorator;

import org.leiwen.dp.structure.decorator.request.HttpServletRequest;

public class HttpServletRequestWrapper implements HttpServletRequest {

private CacheManager cacheManager = new CacheManager();

// 封装了目标接口，而不是具体实现
private HttpServletRequest request;

// HttpServletRequest是一个接口而不是一个具体的实现类，解耦合。
public HttpServletRequestWrapper(HttpServletRequest request) {
this.request = request;
}

@Override
public Object getAttribute(String name) {
// 这样一来，我们就在整个request生命周期获得了HttpServletRequest的扩展：
// 因为对于HttpServletRequest来说，其原生的getAttribute方法的行为被加入了
// “从缓存中读取数据”的新特性。从扩展的灵活度来看，这种实现方法也做到了“从默认目标实现进行选择性扩展”：
// 我们发现可以在这个类的实现中，只有满足以CACHE_PREFIX开始的属性表达式才会被扩展，否将还将调用原始
// 的HttpServletRequest完成逻辑。

// 首先在缓冲中查找，再调用父类方法进行查找
if (name != null && name.startsWith(CacheManager.CACHE_PREFIX)) {
String cacheKey = name
.substring(CacheManager.CACHE_PREFIX.length());
return cacheManager.getValue(cacheKey);
} else {
return request.getAttribute(name);
}

}

@Override
public void setAttribute(String name, Object value) {
request.setAttribute(name, value);
}

}

-----------------------------------------测试装饰模式-------------------------------------------------------

package org.leiwen.dp.structure.decorator.request.test;

import org.leiwen.dp.structure.decorator.request.Filter;
import org.leiwen.dp.structure.decorator.request.FilterChain;
import org.leiwen.dp.structure.decorator.request.HttpServletRequest;
import org.leiwen.dp.structure.decorator.request.HttpServletResponse;
import org.leiwen.dp.structure.decorator.request.impl.DecoratorSampleFilter;
import org.leiwen.dp.structure.decorator.request.impl.FilterChainImpl;
import org.leiwen.dp.structure.decorator.request.impl.HttpServletRequestImpl;

/**
* @author 雷文 2012-3-24
*/
public class DecoratorTest {

// 我们可以把这个main函数想象成Tomcat等Web容器
public static void main(String[] args) {

// “遵循Servlet规范”，构造对象，准备Web环境
HttpServletRequest req = new HttpServletRequestImpl();
req.setAttribute("fans", "I am fans.");
req.setAttribute("leiwen", "Hello,everyone.I am leiwen.");
// 本例的重点不在于此，而在于request。FilterChain和HttpServletResponse完全可以为null。
HttpServletResponse res = null;
FilterChain chain = new FilterChainImpl();

//"Tomcat容器"调用我们自己实现的Filter
Filter filter = new DecoratorSampleFilter();
filter.doFilter(req, res, chain);
}
}

--------------------------------------------------------------------------------------------------------------------------------------------

程序运行结果：