JAVA架构师之路八：设计模式之装饰器模式

雨点打透心脏的1/2处 2022-12-25 04:55 176阅读 0赞

[**JAVA架构师之路七：设计模式之门面模式**][JAVA]

### 装饰器模式 ###

*   *  1. 装饰器模式
     *  2. 不使用装饰器模式写法
     *  3. 抽象继承写法
     *  4. 实战JSON格式日志装饰器
     *  5. 装饰器模式和代理模式的对比

> **无论乌鸦怎样用孔雀的羽毛来装饰自己，乌鸦毕竟是乌鸦。 —— 斯大林**

日常生活中，我们去肯德基、麦当劳吃饭，我们会点很多东西，服务员会在他们的点餐系统选择你点的食物，然后总价和清单就出来了，那这个系统是怎么实现的呢？还有就是我们去饭店，点完餐，服务员也会给一个点餐列表和总金额。今天我们来聊下这种系统利用的一种重要的设计模式——**装饰器模式**

## 1. 装饰器模式 ##

定义

> 装饰器模式也叫包装模式，是指在不改变原有对象的基础上，将功能附加到对象上，提供了比继承更有弹性的替代方案(扩展原有对象的功能)。  
> 属于结构型设计模式。

适用场景

> 扩展一个类的功能或者给一个类添加职责。  
> 动态的给一个对象添加功能，这些功能可以动态的撤销

优点

> 装饰器是继承的有力补充，比继承更灵活，不改变原有对象额情况下动态地给一个对象扩展功能，即插即用  
> 通过使用不同装饰类以及这些装饰类的排列组合，可实现不同效果  
> 装饰器完全遵守开闭原则

缺点

> 会出现更多的代码，更多的类，增加程序的复杂性  
> 动态装饰时，多层装饰会更复杂

## 2. 不使用装饰器模式写法 ##

public class JianBing { 
    
        public String getMsg() { 
            return "煎饼";
        }
    
        public int getPrice() { 
            return 5;
        }
    }

public class JianBingAddEgg extends JianBing { 
    
        @Override
        public String getMsg() { 
            return super.getMsg() + ",加鸡蛋";
        }
    
        @Override
        public int getPrice() { 
            return super.getPrice() + 2;
        }
    }

public class JianBingAddEggAndXiangchang extends JianBingAddEgg { 
        @Override
        public String getMsg() { 
            return super.getMsg() + ",加香肠";
        }
    
        @Override
        public int getPrice() { 
            return super.getPrice() + 2;
        }
    }

public class Test { 
    
        public static void main(String[] args) { 
            JianBing jianBing = new JianBing();
            System.out.println(jianBing.getMsg() + ",总价：" + jianBing.getPrice());
    
            JianBingAddEgg jianBing1 = new JianBingAddEgg();
            System.out.println(jianBing1.getMsg() + ",总价：" + jianBing1.getPrice());
    
            JianBingAddEggAndXiangchang jianBing2 = new JianBingAddEggAndXiangchang();
            System.out.println(jianBing2.getMsg() + ",总价：" + jianBing2.getPrice());
        }
    }

煎饼,总价：5
    煎饼,加鸡蛋,总价：7
    煎饼,加鸡蛋,加香肠,总价：9

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70]  
这种写法有一个很大且不能容忍的缺点，就是类的数目会越来约庞大。

## 3. 抽象继承写法 ##

public abstract class JianBing { 
    
        protected abstract String getMsg();
    
        protected abstract int getPrice();
    }

public class BaseJianBing extends JianBing{ 
    
        @Override
        public String getMsg() { 
            return "煎饼";
        }
    
        @Override
        public int getPrice() { 
            return 5;
        }
    }

public class JianBingDecotator extends JianBing { 
    
        private JianBing jianBing;
    
        public JianBingDecotator(JianBing jianBing) { 
            this.jianBing = jianBing;
        }
    
        @Override
        protected String getMsg() { 
            return this.jianBing.getMsg();
        }
    
        @Override
        protected int getPrice() { 
            return this.jianBing.getPrice();
        }
    }

public class EggDectorator extends JianBingDecotator { 
        public EggDectorator(JianBing jianBing) { 
            super(jianBing);
        }
    
        @Override
        protected String getMsg() { 
            return super.getMsg() + ",1个鸡蛋";
        }
    
        @Override
        protected int getPrice() { 
            return super.getPrice() + 1;
        }
    }

public class XiangchangDectorator extends JianBingDecotator { 
        public XiangchangDectorator(JianBing jianBing) { 
            super(jianBing);
        }
    
        @Override
        protected String getMsg() { 
            return super.getMsg() + ",1根香肠";
        }
    
        @Override
        protected int getPrice() { 
            return super.getPrice() + 2;
        }
    }

public class Test { 
    
        public static void main(String[] args) { 
            JianBing jianBing;
    
            jianBing = new BaseJianBing();
    
            System.out.println(jianBing.getMsg() + ",总价：" + jianBing.getPrice());
    
            jianBing = new EggDectorator(jianBing);
    
            System.out.println(jianBing.getMsg() + ",总价：" + jianBing.getPrice());
    
            jianBing = new EggDectorator(jianBing);
    
            System.out.println(jianBing.getMsg() + ",总价：" + jianBing.getPrice());
    
            jianBing = new XiangchangDectorator(jianBing);
    
            System.out.println(jianBing.getMsg() + ",总价：" + jianBing.getPrice());
    
        }
    }

煎饼,总价：5
    煎饼,1个鸡蛋,总价：6
    煎饼,1个鸡蛋,1个鸡蛋,总价：7
    煎饼,1个鸡蛋,1个鸡蛋,1根香肠,总价：9

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70 1]  
利用抽象继承关系，定义一个最基础的煎饼装饰器，然后不管有什么佐料，都继承这个煎饼装饰器，就可以相加什么加什么，佐料和列表就会在最后计算出来。想一下这种模式的适用场景是不是很常见：我们常去的麦当劳，肯德基等等，是不是这样的呢？

## 4. 实战JSON格式日志装饰器 ##

我们的系统日志一般都是文本日志，不利于日志解析，如果我们想要打印出JSON格式的日志怎么办呢？装饰器模式就很好的帮我们解决了这个问题。  
先来看看原始的日志是什么样的？

public class Test { 
    
        private static final Logger logger = LoggerFactory.getLogger(Test.class);
    
        public static void main(String[] args) { 
            logger.info("系统错误");
        }
    }

[main] INFO org.test.decorator.log.Test - 系统错误

我们来改造下，让它输出JSON格式的日志.  
首先我们要有一个`logger`装饰器`LoggerDecorator`。根据装饰器的特点，`LoggerDecorator`必须要持有`logger`对象。

public class LoggerDecorator implements Logger { 
    
        protected Logger logger;
    
        public LoggerDecorator(Logger logger) { 
            this.logger = logger;
        }
    
        public String getName() { 
            return null;
        }
    
        public boolean isTraceEnabled() { 
            return false;
        }
    
        public void trace(String s) { 
    
        }

实现`logger` 接口。  
第二：我们要有一个`JsonLogger`对象，这个对象要继承装饰器

public class JsonLogger extends LoggerDecorator { 
    
        public JsonLogger(Logger logger) { 
            super(logger);
        }
    
        @Override
        public void info(String s) { 
            JSONObject json = newJsonObject();
            json.put("message", s);
            logger.info(json.toString());
        }
    
        @Override
        public void error(String s) { 
            JSONObject json = newJsonObject();
            json.put("message", s);
            logger.info(json.toString());
        }
    
        public void error(Exception e) { 
            JSONObject json = newJsonObject();
            json.put("exception", e.getClass().getName());
            String trace = Arrays.toString(e.getStackTrace());
            json.put("strackTrace", trace);
            logger.info(json.toString());
        }
    
        private JSONObject newJsonObject() { 
            return new JSONObject();
        }
    }

我们重写了`info`，`error`接口，又重载了`error`接口。  
接下来，我们要定义一个`JsonLoggerFactory`对象

public class JsonLoggerFactory { 
        public static JsonLogger getLogger(Class clazz) { 
            Logger logger = LoggerFactory.getLogger(clazz);
            // 装饰
            return new JsonLogger(logger);
        }
    }

测试：

public class Test { 
        private static final JsonLogger logger = JsonLoggerFactory.getLogger(Test.class);
        public static void main(String[] args) { 
            logger.info("系统错误");
            logger.error("系统错误");
            logger.error(new Exception("运行异常"));
        }
    }

[main] INFO org.test.decorator.log.Test - {"message":"系统错误"}
    [main] INFO org.test.decorator.log.Test - {"message":"系统错误"}
    [main] INFO org.test.decorator.log.Test - {"exception":"java.lang.Exception","strackTrace":"[org.test.decorator.log.Test.main(Test.java:10)]"}

这样就完全改写了日志输出JSON格式。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70 2]

## 5. 装饰器模式和代理模式的对比 ##

> 装饰器模式就是一种特殊的代理模式  
> 装饰器模式强调自身的功能扩展，透明的扩展，可动态定制的扩展  
> 代理模式强调代理过程的控制

**感谢您阅读本文，如果您觉得文章写的对您有用的话，请您点击上面的“关注”，点个赞，这样您就可以持续收到《JAVA架构师之路》的最新文章了。文章内容属于自己的一点点心得，难免有不对的地方，欢迎在下方评论区探讨，你们的关注是我创作优质文章的动力。**

[**JAVA架构师之路九：设计模式之享元模式**][JAVA 1]

[JAVA]: https://blog.csdn.net/cuixhao110/article/details/110095515
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70]: /images/20221120/0aa75a480dda46ea9a794b4470f7a418.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70 1]: /images/20221120/18229549f2234a1b927efa79b923dd51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70 2]: /images/20221120/b9e253420abe44848034099a391f3d60.png
[JAVA 1]: https://blog.csdn.net/cuixhao110/article/details/110850067