设计模式之装饰者模式

拼搏现实的明天。 2022-10-22 01:40 205阅读 0赞

# 一：装饰者模式的使用场景 #

*  需要扩展一个类的功能，或给一个类增加附加功能。
 *  需要动态的给一个对象增加功能，这些功能可以再动态的撤销。
 *  需要为一批的兄弟类进行改装或加装功能。

核心：就是功能的增强

比如在mybatis中的二级缓存就使用了装饰者模式。

# 二：代码实现 #

装饰模式的通用类图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70][]

Component实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:08
     */
    public abstract class Component {
    
        /**
         * 抽象的方法
         */
        public abstract void operate();
    }

ConcreteComponent实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:10
     */
    public class ConcreteComponent extends Component {
    
        /**
         * 具体实现
         */
        @Override
        public void operate() {
            System.out.println("do Something");
        }
    }

Decorator实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:13
     */
    public abstract class Decorator extends Component {
    
        private Component component = null;
    
        /**
         * 通过构造函数传递被修饰者
         * @param component
         */
        public Decorator(Component component) {
            this.component = component;
        }
    
        /**
         * 委托给装饰者执行
         */
        @Override
        public void operate() {
            this.component.operate();
        }
    }

ConcreteDecorator1实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:16
     */
    public class ConcreteDecorator1 extends Decorator {
    
        /**
         * 定义被修饰者
         * @param component
         */
        public ConcreteDecorator1(Component component) {
            super(component);
        }
    
        /**
         * 定义自己的修饰方法
         */
        private void method1() {
            System.out.println("method1 修饰");
        }
    
        /**
         * 重写父类的operate方法
         */
        @Override
        public void operate() {
            this.method1();
            super.operate();
        }
    
    
    }

ConcreteDecorator2实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:16
     */
    public class ConcreteDecorator2 extends Decorator {
    
        /**
         * 定义被修饰者
         * @param component
         */
        public ConcreteDecorator2(Component component) {
            super(component);
        }
    
        /**
         * 定义自己的修饰方法
         */
        private void method2() {
            System.out.println("method2 修饰");
        }
    
        /**
         * 重写父类的operate方法
         */
        @Override
        public void operate() {
            super.operate();
            this.method2();
        }
    
    
    }

Client实体类：

package decorator;
    
    /**
     * @author lizhangyu
     * @date 2021/5/2 12:21
     */
    public class Client {
    
        public static void main(String[] args) {
            Component component = new ConcreteComponent();
            //第一次修饰
            component = new ConcreteDecorator1(component);
            //第二次修饰
            component = new ConcreteDecorator2(component);
            //修饰后运行
            component.operate();
        }
    }

运:行结果：

method1 修饰
    do Something
    method2 修饰

# 三：装饰者模式的优点和缺点 #

## 1：优点 ##

扩展性强，耦合度低

## 2：缺点 ##

系统复杂度增强，调试起来麻烦。

# 四：装饰者模式和代理模式的区别 #

两者都可以进行功能的增强，但是装饰者模式是通过添加装饰类来实现的，而代理是通过生成代理对象来实现，不需要自己手动增加类来实现。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]: /images/20221022/72faca6412b240b7bc8e68963bf58b2e.png