装饰者设计模式（一）

妖狐艹你老母 2024-04-06 11:45 49阅读 0赞

#### 装饰者设计模式 ####

*  一、简单原理
 *  二、遵循的开发规则
 *  三、代码演示
 *   *   *  1、先开发一个简单的接口和实现类，暂时不含有装饰者模式
         *  2、增加需求
         *  3、再增加需求

## 一、简单原理 ##

简单点说，就是 在不修改目标类的前提下，对目标类的方法进行增强

## 二、遵循的开发规则 ##

1、装饰者类与目标类要实现相同的接口，或继承自相同的抽象类

2、装饰者类中要有目标类的引用作为成员变量，而具体的实现一般通过带参构造器完成

## 三、代码演示 ##

#### 1、先开发一个简单的接口和实现类，暂时不含有装饰者模式 ####

接口类 ISomeService

/**
     * 业务逻辑接口
     */
    public interface ISomeService {
        
        //目标方法
        String doSome();
    }

接口实现类 SomeService

/**
     * 目标类
     */
    public class SomeService implements ISomeService {
        
        @Override
        public String doSome() {
        
            return "abcde";
        }
    }

测试类

public class TestMain {
        
        public static void main(String[] args) {
        
            ISomeService someService = new SomeService();
            String res = someService.doSome();
            System.out.println(res);
        }
    }

#### 2、增加需求 ####

（1）要求在调用doSome()方法的时候，直接就可以获取到大写字母的返回值  
（2）不可以修改目标类方法的返回值，比如通过"abcde".toUpperCase();，这样是不允许的  
![在这里插入图片描述][d4a99d5174534a73a1070eda90f2b192.png]  
总结一句话就是：在不修改目标类的前提下，对目标类的方法进行增强，功能的增强，这个就符合装饰者设计模式的场景。

接下来我们现在一个装饰者类：SomeServiceDecorator

package com.decorator;
    
    /**
     * 装饰者：
     *      1、装饰者类与目标类要实现相同的接口，或继承自相同的抽象类
     *      2、装饰者类中要有目标类的引用作为成员变量，而具体的实现一般通过带参构造器完成
     */
    public class SomeServiceDecorator implements ISomeService {
        
        //目标对象
        private ISomeService target;
        //通过带参构造器传入目标对象
        public SomeServiceDecorator(ISomeService target) {
        
            this.target = target;
        }
    
        @Override
        public String doSome() {
        
            return target.doSome().toUpperCase();
        }
    }

测试类调用一下

public class TestMain2 {
        
        public static void main(String[] args) {
        
        	//目标对象
            ISomeService target = new SomeService();
            //创建装饰者
            SomeServiceDecorator someService = new SomeServiceDecorator(target);
            String res = someService.doSome();
            System.out.println(res);//输出结果：ABCDE
        }
    }

总结：满足开闭原则，即 原有的代码不修改，通过增加新的类

#### 3、再增加需求 ####

有两个目标类，一个需要将字母变成大写，另外一个需要在返回值后面加上123数字，此时现有的装饰者类已经不能满足要求了，因为他只能满足单个目标类的使用

创建 装饰者的父类或基类 SomeServiceWapper

package com.decorator.wapper;
    
    import com.decorator.ISomeService;
    
    /**
     * 装饰者的父类或基类：
     * 1、要有无参构造器
     * 2、只是调用目标类的目标方法，但不对其进行任何的增强
     */
    public class SomeServiceWapper implements ISomeService {
        
        //目标对象
        private ISomeService target;
    
        public SomeServiceWapper() {
         }
        //通过带参构造器传入目标对象
        public SomeServiceWapper(ISomeService target) {
        
            this.target = target;
        }
    
        //只是调用目标类的目标方法，但不对其进行任何的增强
        @Override
        public String doSome() {
        
            return target.doSome();
        }
    }

具体装饰者类 UpperDecorator ，做大小写切换

package com.decorator;
    
    import com.decorator.wapper.SomeServiceWapper;
    
    /**
     * 具体装饰者类
     * 1、要继承 装饰者基类
     * 2、要有带参构造器
     * 3、具体装饰者只对装饰者基类业务方法进行某一种单一的增强
     */
    public class UpperDecorator extends SomeServiceWapper {
        
    
        public UpperDecorator() {
        
            super();
        }
    
        public UpperDecorator(ISomeService target) {
        
            super(target);
        }
    
        //重写基类的方法
        @Override
        public String doSome() {
        
            //调用业务方法，进行增强
            return super.doSome().toUpperCase();
        }
    }

具体装饰者类 CharterDecorator ，做字符串拼接

package com.decorator;
    
    import com.decorator.wapper.SomeServiceWapper;
    public class CharterDecorator extends SomeServiceWapper {
        
        public CharterDecorator() {
        
            super();
        }
    
        public CharterDecorator(ISomeService target) {
        
            super(target);
        }
    
        //重写基类的方法
        @Override
        public String doSome() {
        
            //调用业务方法，进行增强
            return super.doSome() + "123";
        }
    }

测试类调用一下

package com.decorator;
    
    public class TestMain3 {
        
        public static void main(String[] args) {
        
            ISomeService target = new SomeService();
            ISomeService someService = new UpperDecorator(target);
            System.out.println(someService.doSome());//ABCDE
    
            ISomeService someService2 = new CharterDecorator(target);
            System.out.println(someService2.doSome());//abcde123
    
            //如果将第一次增强的结果，作为第二次增强的参数出现，此时会形成 “装饰者链”
            ISomeService someService3 = new CharterDecorator(someService);
            System.out.println(someService3.doSome());//ABCDE123
        }
    }

[d4a99d5174534a73a1070eda90f2b192.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/b2ae8245357449ca8f602eaf7b21695c.png