java设计模式（适配器、装饰者、责任链、观察者）

适配器模式：

package com.xiaowei.designpattern;

public class AdapterModeTest {
    /**
     * 适配器模式 模式定义： 将一个类的接口转换成客户希望的另一个接口。
     * Adapter模式使得原来由于接口不兼容而不能一起工作的那些类 可以一起工作。
     * 比如电源转换，220V，电脑、手机、低功率电器的一些适配。 
     * 分两种：对象适配器模式（组合）和类适配器模式（继承）。
     * 应用场景:
     * 1、当你希望使用某些现有类，但其接口与您的其他代码不兼容时，请使用适配器模式；
     * 2、当你希望重用几个现有的子类，这些子类缺少一些不能添加到超类的公共功能时，请使用该模式；
     * 
     * 优点：
     * 1、符合单一职责原则
     * 2、符合开闭原则。
     */
    public static void main(String[] args) {
        // 对象适配器模式,组合
//        Target adapter = new Adapter(new Adaptee());
//        adapter.output5v();
        
        // 类适配器模式,继承
        // 对接口有污染，不符合迪米特原则
        ClassAdapter classAdapter = new ClassAdapter();
        classAdapter.output5v();
    }
}

class Adaptee {
    public int output220v() {
        return 220;
    }
}

interface Target {
    int output5v();
}

/**
 * Object Adapter
 */
class Adapter implements Target {

    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public int output5v() {
        int output220v = adaptee.output220v();
        System.out.println(String.format("原始电压：  %d    -->   输出电压:  %d", output220v, 5));
        return 5;
    }
}

/**
 * Class Adapter
 */
class ClassAdapter extends Adaptee implements Target {

    @Override
    public int output5v() {
        int output220v = output220v();
        System.out.println(String.format("原始电压：  %d    -->   输出电压:  %d", output220v, 5));
        return 5;
    }
    
}

装饰者设计模式：

package com.xiaowei.designpattern;

public class DecoratorModeTest {
    /**
     * 装饰着模式定义：
     * 在不改变原有对象的基础上，将功能附加到对象上。符合开闭原则。对修改关闭，对拓展开放。
     * 
     * 优点:
     * 1、不改变原有对象的情况下给一个对象扩展功能
     * 2、使用不同的组合可以实现不同的效果
     * 3、符合开闭原则
     */
    public static void main(String[] args) {
        Component component = new ConcreateDecorator2(new ConcreateDecorator1(new ConcreateDecorator()));
        component.operation();
    }
}

interface Component {
    void operation();
}

class ConcreateDecorator implements Component {

    @Override
    public void operation() {
        System.out.println("拍照");
    }
}

abstract class Decorator implements Component {
    // 持有Component引用，才可以对进行装饰
    Component component;
    
    public Decorator(Component component) {
        this.component = component;
    } 
}

class ConcreateDecorator1 extends Decorator {

    ConcreateDecorator1(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("添加美颜效果......");
        component.operation();
    }    
}

class ConcreateDecorator2 extends Decorator {

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

    @Override
    public void operation() {
        System.out.println("添加滤镜效果......");
        component.operation();
    }    
}

责任链设计模式：

package com.xiaowei.designpattern;

public class ChainOfResponsibilityModeTest {
    
    /**
     * 责任链模式
     * 模式定义:
     * 1、为请求创建了一个接收者对象的链。
     * 
     * 比如okhttp请求，请求频率、登录认证、访问权限、敏感词过滤。
     * 
     * 应用场景：
     * 一个请求的处理需要多个对象当中的一个或几个协作处理
     * 
     * 优点：
     * 1、请求的发送者和接收者解耦
     * 2、可以控制执行顺序
     * 3、符合开闭原则和单一职责原则
     */
    public static void main(String[] args) {
        Request request = new Request.RequestBuilder().frequentOk(true).loggedOn(false).build();
        RequestFrequentHandler requestFrequentHandler = new RequestFrequentHandler(new LoggingHandler(null));
        if (requestFrequentHandler.process(request)) {
            System.out.println("正常业务处理:");
        } else {
            System.out.println("访问异常:");
        }
    }
}

class Request{
    private boolean loggedOn;
    private boolean frequentOk;
    private boolean isPermits;
    private boolean containsSensitiveWords;
    private String requestBody;

    public boolean isLoggedOn() {
        return loggedOn;
    }
    public void setLoggedOn(boolean loggedOn) {
        this.loggedOn = loggedOn;
    }
    public boolean isFrequentOk() {
        return frequentOk;
    }
    public void setFrequentOk(boolean frequentOk) {
        this.frequentOk = frequentOk;
    }
    public boolean isPermits() {
        return isPermits;
    }
    public void setPermits(boolean isPermits) {
        this.isPermits = isPermits;
    }
    public boolean isContainsSensitiveWords() {
        return containsSensitiveWords;
    }
    public void setContainsSensitiveWords(boolean containsSensitiveWords) {
        this.containsSensitiveWords = containsSensitiveWords;
    }
    public Request(boolean loggedOn, boolean frequentOk, boolean isPermits, boolean containsSensitiveWords) {
        this.loggedOn = loggedOn;
        this.frequentOk = frequentOk;
        this.isPermits = isPermits;
        this.containsSensitiveWords = containsSensitiveWords;
    }
    static class RequestBuilder{
        private boolean loggedOn;
        private boolean frequentOk;
        private boolean isPermits;
        private boolean containsSensitiveWords;
        
        public Request build() {
            return new Request(loggedOn, frequentOk, isPermits, containsSensitiveWords);
        }
        
        RequestBuilder loggedOn(boolean loggedOn) {
            this.loggedOn = loggedOn;
            return this;
        }
        RequestBuilder frequentOk(boolean frequentOk) {
            this.frequentOk = frequentOk;
            return this;
        }
        RequestBuilder isPermits(boolean isPermits) {
            this.isPermits = isPermits;
            return this;
        }
        RequestBuilder containsSensitiveWords(boolean containsSensitiveWords) {
            this.containsSensitiveWords = containsSensitiveWords;
            return this;
        }
    }
}

abstract class Handler {
    Handler next;
    public Handler(Handler next) {
        this.next = next;
    }
    
    public void setNext(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }
    
    abstract boolean process(Request request);
}

class RequestFrequentHandler extends Handler {

    public RequestFrequentHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("访问频率控制:");
        if (request.isFrequentOk()) {
            Handler next = getNext();
            if (null == next) {
                return true;
            }
            if (!next.process(request)) {
                return false;
            } else {
                return true;
            }
        }
        return false;
    }
}

class LoggingHandler extends Handler {

    public LoggingHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("登录访问控制:");
        if (request.isLoggedOn()) {
            Handler next = getNext();
            if (null == next) {
                return true;
            }
            if (!next.process(request)) {
                return false;
            } else {
                return true;
            }
        }
        return false;
    }
}

观察者设计模式：

package com.xiaowei.designpattern;

import java.util.ArrayList;

public class ObserverModeTest {
    
    /**
     * 观察者模式:
     * 模式定义：
     * 1、定义了对象的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的
     * 所有的依赖着都会收到这样的通知并更新。
     * 
     * 应用场景：
     * 1、当更改一个对象的状态可能需要更改其他对象，并且实际的对象事先未知或动态更改时请使用观察者模式。
     * 
     * 优点：
     * 1、符合开闭原则
     * 2、可以在运行时建立对象直接的关系
     */
    public static void main(String[] args) {
        Subject subject = new Subject();
        Task1 task1 = new Task1();
        subject.addObserver(task1);
        Task2 task2 = new Task2();
        subject.addObserver(task2);
        subject.notifyObserver("xxxx");
        System.out.println("===================");
        subject.removeObserver(task1);
        subject.notifyObserver("yyyy");
    }
}

class Subject {
    // 容器
    private java.util.List<Observer> container = new ArrayList<>();
    
    // 添加
    public void addObserver(Observer observer) {
        container.add(observer);
    }
    
    // remove
    public void removeObserver(Observer observer) {
        container.remove(observer);
    }
    
    public void notifyObserver(Object object) {
        for (Observer observer : container) {
            observer.update(object);
        }
    }
}

interface Observer{
    void update(Object object);
}

/**
 * 观察者1
 */
class Task1 implements Observer {

    @Override
    public void update(Object object) {
        System.out.println("task1 received : " + object);
    }
}

/**
 * 观察者2
 */
class Task2 implements Observer {

    @Override
    public void update(Object object) {
        System.out.println("task2 received : " + object);
    }
}