装饰模式（Decorator Pattern）

Posted 2021-07-23 顧棟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了装饰模式（Decorator Pattern）相关的知识，希望对你有一定的参考价值。

文章目录

装饰模式（Decorator Pattern）

装饰模式（Decorator Pattern）

装饰模式的定义

指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

装饰模式的优点

采用装饰模式扩展对象的功能比采用继承方式更加灵活。
可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。
装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无须知道Decorator类，Decorator类是从外部来扩展Component类的功能，而Decorator也不用知道具体的构件。
装饰模式是继承关系的一个替代方案。我们看装饰类Decorator，不管装饰多少层，返回的对象还是Component，实现的还是is-a的关系。

装饰模式的缺点

装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。因此，尽量减少装饰类的数量，以便降低系统的复杂度。

装饰模式的结构

装饰模式主要包含以下角色。

抽象构件（Component）角色：定义一个抽象接口或者抽象类，以规范准备接收附加责任的对象。
具体构件（Concrete Component）角色：实现抽象构件，是最核心、最原始、最基本的接口或抽象类的实现，可以是一组。通过装饰角色为其添加一些职责。
抽象装饰（Decorator）角色：是一个抽象类，继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
具体装饰（Concrete Decorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

装饰模式的实现

（1）单点登录功能的扩展采用装饰器实现

public interface HandlerInterceptor {
    boolean preHandle(String request, String response, Object handler);
}

public class SsoInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(String request, String response, Object handler) {
        // 模拟获取cookie
        String ticket = request.substring(1, 8);
        // 模拟校验
        return ticket.equals("success");
    }
}

public class SsoDecorator implements HandlerInterceptor {
    private HandlerInterceptor handlerInterceptor;

    private SsoDecorator() {
    }

    public SsoDecorator(HandlerInterceptor handlerInterceptor) {
        this.handlerInterceptor = handlerInterceptor;
    }

    @Override
    public boolean preHandle(String request, String response, Object handler) {
        return handlerInterceptor.preHandle(request, response, handler);
    }
}

public class LoginSsoDecorator extends SsoDecorator {
    private static final Map<String, String> authMap = new ConcurrentHashMap<String, String>();

    static {
        authMap.put("huahua", "queryUserInfo");
        authMap.put("doudou", "queryUserInfo");
    }

    public LoginSsoDecorator(HandlerInterceptor handlerInterceptor) {
        super(handlerInterceptor);
    }

    @Override
    public boolean preHandle(String request, String response, Object
            handler) {
        boolean success = super.preHandle(request, response, handler);
        if (!success) {
            return false;
        }
        String userId = request.substring(8);
        String method = authMap.get(userId);
        System.out.println("模拟单点登录方法访问拦截校验" + userId + " " + method);
        return "queryUserInfo".equals(method);
    }
}

public static void main(String[] args) {
    LoginSsoDecorator ssoDecorator = new LoginSsoDecorator(new SsoInterceptor());
    String request = "1successhuahua";
    boolean success = ssoDecorator.preHandle(request, "ewcdqwt40liuiu", "t");
    System.out.println("登录校验：" + request + (success ? " 放行" : " 拦截"));
}

（2）常规装饰模式实现

// 抽象构件角色
public abstract class Component {
    //抽象的方法
    public abstract void operate();
}

// 具体构件角色
public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("do Something");
    }
}

// 抽象装饰角色
public abstract class Decorator extends Component {
    private Component component = null;

    /**
     * 通过构造函数传递被修饰者
     */
    public Decorator(Component component) {
        this.component = component;
    }

    /**
     * 委托给被修饰者执行
     */
    @Override
    public void operate() {
        this.component.operate();
    }
}

//具体装饰 角色1
public class ConcreteDecorator1 extends Decorator {
    /**
     * 定义被修饰者
     */
    public ConcreteDecorator1(Component component) {
        super(component);
    }

    /**
     * 定义自己的修饰方法
     */
    private void method1() {
        System.out.println("method1 修饰");
    }

    /**
     * 重写父类的Operation方法
     */
    @Override
    public void operate() {
        this.method1();
        super.operate();
    }
}

// 具体装饰 角色2
public class ConcreteDecorator2 extends Decorator {//定义被修饰者

    public ConcreteDecorator2(Component component) {
        super(component);
    }

    /**
     * 定义自己的修饰方法
     */
    private void method2() {
        System.out.println("method2修饰");
    }

    /**
     * 重写父类的Operation方法
     */
    @Override
    public void operate() {
        super.operate();
        this.method2();
    }
}

public static void main(String[] args) {
    Component component = new ConcreteComponent();
    //第一次修饰
    component = new ConcreteDecorator1(component);
    //第二次修饰
    component = new ConcreteDecorator2(component);
    //修饰后运行
    component.operate();
}