装饰模式

1 对象增强的手段

* 继承

  被增强的对象固定的

  增强的内容也是固定的

  使用继承会使类增多

class 咖啡类 {}


class 有糖咖啡 extends 咖啡类 {}


class 加奶咖啡 extends 咖啡类 {}


class 加糖加奶 extends 加奶咖啡 ,有糖咖啡{}

 

* 动态代理（AOP）

  被增强的对象可以切换

  增强的内容也可以切换：事务处理 日志 ... ...

  参看：Java 动态代理

 

* 装饰者模式

  被增强的对象是可以切换的

  增强的内容是固定的

 

2 Decorator 模式

动态给一个对象添加一些额外的职责,就像在墙上刷油漆.

使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活.

也就是说：动态地给对象添加一些额外的功能。

它的工作原理是：创建一个始于Decorator对象（负责新功能的对象）终止于原对象的一个对象的“链”。

装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

装饰模式以对客户端透明的方式动态的给一个对象附加上更多的责任。换言之客户端并不会觉的对象在装饰前和装饰后有什么区别。

装饰模式可以在不创造更多的子类的模式下，将对象的功能加以扩展。

 

Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：

public interface Sourceable {  
public void method()
};  

public class Source implements Sourceable {  
  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  

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!");  
    }  
} 

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!

 

窍门：是你还有你，一切拜托你

is a

has a

use a

 

1.包装类要和被包装的对象实现同样的接口

2.包装类要持有一个被包装对象

3.包装类在实现接口的时候，对于不需要包装的方法调用被包装对象的方法来实现，对于需要包装的方法，我们自己实现

class MyConnection implements Connection {//是你
    
    private Connection con;// 还有你 底层对象，被增强对象

    public MyConnection(Connection con){//通过构造器传递底层对象！
        this.con = con;
    }

    // 一切拜托你 不需要去改动的方法直接使用目标对象的方法
    public Statement createStatement() {
        return con.createStatement();
    }

    // 增强点
    public void close(){
        //把当前连接归还给池！
    }
}

Connection con =   通过四大参数创建连接对象！是由mysql提供的！
Connection con1 = new MyConnection(con);

con1.createStatement()
con.createStatement();

con1.close();
con.close();

 

 装饰模式与类继承的区别：

  1)     装饰模式是一种动态行为，对已经存在类进行随意组合，

      而类的继承是一种静态的行为，一个类定义成什么样的，该类的对象便具有什么样的功能，无法动态的改变。

  2)  装饰模式扩展的是对象的功能，不需要增加类的数量，而类继承扩展是类的功能，

      在继承的关系中，如果我们想增加一个对象的功能，我们只能通过继承关系，在子类中增加两个方法。

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

 

应用：

 

示例1 : IO

回顾BufferedInputStream(包装类)，FileInputStream读取数据的时候是一个字节一个字节的读取，效率很低，确实实现了读取文件。

需要对 FileInputStream 进行包装， 提高读取效率，BufferedInputStream就是这样的包装类， 内置了缓冲区

BufferedInputStream称为包装类   FileInputStream称为被包装对象

 

FileInputSteram：它是节点流！就是和一个资源绑定在一起的！文件！

BufferedInputStream：它是装饰流！创建我是一定要给我一个底层对象，然后我不管你给我的是什么流，我都会给它添加缓冲区！

new BufferedInputStream(任意的InputStream)

 

public class BufferedInputStream extends FilterInputStream {  //是你 继承了FilterInputStream

    protected volatile byte buf[];

    public BufferedInputStream(InputStream in) {
        this(in, defaultBufferSize);
    }

    public BufferedInputStream(InputStream in, int size) {
        super(in); //有你  在父类FilterInputStream已经存在里一个(见下面的FilterInputStream类)
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
       buf = new byte[size];
    }

   private InputStream getInIfOpen() throws IOException {//获取需要加强的对象
        InputStream input = in;
        if (input == null)
           throw new IOException("Stream closed");
        return input;
    }
  
  //方法增强
  public synchronized int read() throws IOException {
    if (pos >= count) {
        fill();
        if (pos >= count)
        return -1;
    }
      return getBufIfOpen()[pos++] & 0xff;
   }

  //方法增强
  public synchronized int read(byte b[], int off, int len)throws IOException {
        getBufIfOpen(); // Check for closed stream
        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
        throw new IndexOutOfBoundsException();
    } else if (len == 0) {
            return 0;
        }

    int n = 0;
        for (;;) {
            int nread = read1(b, off + n, len - n);
            if (nread <= 0) 
                return (n == 0) ? nread : n;
            n += nread;
            if (n >= len)
                return n;
            // if not closed but no bytes available, return
            InputStream input = in;
            if (input != null && input.available() <= 0)
                return n;
        }
    }
  。。。 。。。
}


public class FilterInputStream extends InputStream {

    protected volatile InputStream in;  

    protected FilterInputStream(InputStream in) {
       this.in = in;
    }

}

 

 

案例2 HttpRequest

• 装饰 HttpServletRequest 对象

需求：在 HttpServletRequest 对象到达 Servlet 之前把用户输入的多余空格都去掉

情景：因为 HttpServletRequest 对象里的请求参数都实际包含在 java.util.Map 对象里，

 而Map是不允许修改的，所以包含在 HttpServletRequest 对象里的请求参数不能被修改

解决方案：采取 Decorator(装饰器)模式

 

• HttpServletRequestWrapper 类（默认适配器模式）

Servlet API 中提供了一个 HttpServletRequestWrapper 类来包装原始的 request 对象，

HttpServletRequestWrapper 类实现了 HttpServletRequest 接口中的所有方法，

这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法

相类似 Servlet API 也提供了一个 HttpServletResponseWrapper 类来包装原始的 response 对象

 

package com.yiwei.utils.web.filter;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

/**
 * 对GET请求参数加以处理！
 * 装饰request
 */
public class GetRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;
    private String charset;
    
    public GetRequest(HttpServletRequest request, String charset) {
        super(request);
        this.request = request;
        this.charset = charset;
    }

    @Override
    public String getParameter(String name) {
        // 获取参数
        String value = request.getParameter(name);
        if(value == null) return null;//如果为null，直接返回null
        try {
            // 对参数进行编码处理后返回
            return new String(value.getBytes("ISO-8859-1"), charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
    
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public Map getParameterMap() {
        Map<String,String[]> map = request.getParameterMap();
        if(map == null) return map;
        // 遍历map，对每个值进行编码处理
        for(String key : map.keySet()) {
            String[] values = map.get(key);
            for(int i = 0; i < values.length; i++) {
                try {
                    values[i] = new String(values[i].getBytes("ISO-8859-1"), charset);
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        // 处理后返回
        return map;
    }
    
    @Override
    public String[] getParameterValues(String name) {
        String[] values = super.getParameterValues(name);
        for(int i = 0; i < values.length; i++) {
            try {
                values[i] = new String(values[i].getBytes("ISO-8859-1"), charset);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }
        return values;
    }
}

public class EncodingFilter implements Filter {
    private String charset = "UTF-8";
    @Override
    public void destroy() {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
       throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        if(req.getMethod().equalsIgnoreCase("GET")) {
            if(!(req instanceof GetRequest)) {
                req = new GetRequest(req, charset);//处理get请求编码
            }
        } else {
            req.setCharacterEncoding(charset);//处理post请求编码
        }
        chain.doFilter(req, response);
    }

    @Override
    public void init(FilterConfig fConfig) throws ServletException {
        String charset = fConfig.getInitParameter("charset");
        if(charset != null && !charset.isEmpty()) {
            this.charset = charset;
        }
    }
}