从源代码的角度理解Java设计模式的装饰模式

- 日理万妓 2022-04-05 11:49 172阅读 0赞

## 一、装饰模式介绍 ##

修饰符模式定义：不改变原始对象的附加函数比生成子类更灵活。

适用场景：动态的给一个对象添加或者撤销功能。

优点：它能够在不改变原有对象的情况下动态扩展函数，使扩展函数按照期望的顺序执行，达到不同的效果。

缺点：更多的类，使程序复杂

类型：结构型。

类图：

![88a6eb49ce603aa871b7847722a291d54f6.jpg][]

源码分析中的典型应用

*  Java I/O 中的装饰者模式
 *  Spring Session 中的装饰者模式
 *  Mybatis 缓存中的装饰者模式

## 二、给系统添加日志，安全、限流示例 ##

可以抽取出通用系统的安全性、日志、当前限制等独立于业务的代码，在控制器转换前后使用模板法模式可以部分解决上述问题。

public abstract class BaseAspect {
        Logger logger = LoggerFactory.getLogger(BaseCommand.class);
        public void execute(){
    	    //记录日志
            logger.debug("..start..");
           //过滤跨站脚本攻击
           paramXssAspect();
            //限制速率
            doRateLimit();
    
            doBusiness();
    
            logger.debug("..end..");
        }
        public abstract void doBusiness();
    
    }
    class PlaceOrderAspect extends BaseAspect {
        @Override
        public void doBusiness() {
            //下单操作
        }
    }
    class PayOrderAspect extends BaseAspect {
        @Override
        public void doBusiness() {
            //支付操作
        }
    }

在父类中，已经编写了“杂乱”的非业务代码，只剩下一个抽象的方法和其他子类来实现，子类变得非常清新，只关注业务逻辑。  
这种方法的最大缺点是父类定义了一切：为了执行那些非业务代码，按照什么顺序等等，子类只能被无条件地接受。如果有一个子类不限制速率，那么它就无法摆脱它。

通过使用装饰器模型，我们可以灵活地处理上述问题。

//最高层抽象组件
    interface IAspect {
        String doHandlerAspect();
    }
    
    //基本被装饰类,做一些公共处理
    class AspectImpl implements IAspect{
    
        @Override
        public String doHandlerAspect() {
            return "裸跑代码.";
        }
    }
    
    abstract class AbstractDecorator implements IAspect{
        //很重要,组合抽象构件到自己的类中
        private IAspect aspect;
    
        public AbstractDecorator(IAspect aspect) {//通过IAspect构造自己
            this.aspect = aspect;
        }
        @Override
        public String doHandlerAspect() {
            return this.aspect.doHandlerAspect();
        }
    }

附加记录日志，安全，限流功能：

class LoggerAspect extends  AbstractDecorator{
        public LoggerAspect(IAspect aspect){
            super(aspect);
        }
        @Override
        public String doHandlerAspect() {
            return super.doHandlerAspect()+"+记录日志.";
        }
    }
    class ParamXssAspect extends  AbstractDecorator{
        public ParamXssAspect(IAspect aspect){
            super(aspect);
        }
        @Override
        public String doHandlerAspect() {
            return super.doHandlerAspect()+"+过滤危险字符.";
        }
    }
    class LimitAspect extends  AbstractDecorator{
        public LimitAspect(IAspect aspect){
            super(aspect);
        }
        @Override
        public String doHandlerAspect() {
            return super.doHandlerAspect()+"+限流.";
        }
    }

测试一下：

public class Test {
        public static void main(String[] args) {
            IAspect aspect = new LimitAspect(new ParamXssAspect(new LoggerAspect(new AspectImpl())));
            System.out.println(aspect.doHandlerAspect());
        }
    }

运行结果：

\------

裸跑代码.+记录日志.+过滤危险字符.+限流.

\------

从上面可以看出，装饰器模式可以按任意顺序组装函数，是否非常灵活？此外，上述三个函数还可以封装到注释@Log、@ParamXss、@AccessLimit中以实现可插拔性。

## 三、源码中的装饰者模式 ##

**3.1、Java IO中是体现最明显的装饰者模式。**

它是.stream(InputStream/OutputStream)，bytestream(Reader/Writer)是类，InputStream中的输入，ReaderClass：

![8d5639d32d2dfe24420b7f6db3d2d01d493.jpg][]

![3ba53d1aecb061c1476982271cf3337f000.jpg][]

这里总结几种常用流的应用场景：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkMDkwNDQ5MDFndWlj_size_16_color_FFFFFF_t_70][]

**3.2、Spring Session中的ServletRequestWrapper（Response也一样）的装饰者模式。**

public class ServletRequestWrapper implements ServletRequest {
        private ServletRequest request;//组合抽象接口到自己的类中
    
        public ServletRequestWrapper(ServletRequest request) {//可以构造自己
            if(request == null) {
                throw new IllegalArgumentException("Request cannot be null");
            } else {
                this.request = request;
            }
        }
    
        public ServletRequest getRequest() {
            return this.request;
        }
    
        public void setRequest(ServletRequest request) {
            if(request == null) {
                throw new IllegalArgumentException("Request cannot be null");
            } else {
                this.request = request;
            }
        }
       //省略...
    }

**3.3、Spring Cache中的TransactionAwareCacheDecorator的装饰者模式。**

其实从类名就可以看出。

public class TransactionAwareCacheDecorator implements Cache {
        private final Cache targetCache;//把Cache组合到自己类中
    
        public TransactionAwareCacheDecorator(Cache targetCache) {//通过Cache构造自己
            Assert.notNull(targetCache, "Target Cache must not be null");
            this.targetCache = targetCache;
        }
    
        public <T> T get(Object key, Class<T> type) {
            return this.targetCache.get(key, type);
        }
    
        public void put(final Object key, final Object value) {
            // 判断是否开启了事务
            if (TransactionSynchronizationManager.isSynchronizationActive()) {
                // 将操作注册到 afterCommit 阶段
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                    public void afterCommit() {
                        TransactionAwareCacheDecorator.this.targetCache.put(key, value);
                    }
                });
            } else {
                this.targetCache.put(key, value);
            }
        }
        // ...省略...
    }

**3.4、Mybatis中的装饰者。**

Cache是一个抽象的组件类，PerpetualCache是一个具体的组件类，decorators包下的类是装饰类。没有抽象装饰类。

[88a6eb49ce603aa871b7847722a291d54f6.jpg]: /images/20220405/ff433ca4ab914da690fdd3510d1bd880.png
[8d5639d32d2dfe24420b7f6db3d2d01d493.jpg]: /images/20220405/249e9c6988f44246b789b21ca060f384.png
[3ba53d1aecb061c1476982271cf3337f000.jpg]: /images/20220405/38b18e5e75604487bb7ca6549fe98a0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NkMDkwNDQ5MDFndWlj_size_16_color_FFFFFF_t_70]: /images/20220405/1f6d9f5fd79a414a840db669f85fa92d.png