设计模式6 模板方法模式 观察者模式 责任链模式

1、模板方法模式

package Thread;

public class test {
    public static void main(String[] args) {
        AbstractClass abstractClass = new SubClass();
        abstractClass.operation();
    }
}

abstract class  AbstractClass{
    public  void operation(){
        System.out.println("pre   ...");
        System.out.println("step1 ...");
        System.out.println("step2 ...");
        System.out.println("step3 ...");
        templateMethod();
    }

    protected abstract void templateMethod();
}

class SubClass extends AbstractClass{

    @Override
    protected void templateMethod() {
        System.out.println("SubClass executed..");
    }
}

2、观察者模式

package Thread;

import java.util.ArrayList;
import java.util.List;

public class test {
    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.remove(task1);
        subject.notifyObserver("yyyy");
    }
}
interface Observer{
    void update(Object object);
}

class Subject{
    //容器
    private List<Observer> container = new ArrayList<>();
    //add
    public void addObserver(Observer observer){
        container.add(observer);
    }
    //remove
    public void remove(Observer observer){
        container.remove(observer);
    }
    public void notifyObserver(Object object){
        for (Observer item : container) {
            item.update(object);
        }
    }
}
class Task1 implements Observer{
    @Override
    public void update(Object object) {
        System.out.println("Task1 received:" + object);
    }
}

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

3、责任链模式

package Thread;

import java.util.ArrayList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        Request.RequestBuilder requestBuilder = new Request.RequestBuilder();
        requestBuilder.frequentOk(true);
        requestBuilder.loggedOn(true);
        requestBuilder.isPermits(true);
        requestBuilder.containsSensitiveWords(true);
        Request request = requestBuilder.build();
        //Request request = new Request.RequestBuilder().frequentOk(true).loggedOn(true).isPermits(true).containsSensitiveWords(true).build();
        LoggingHandler loggingHandler = new LoggingHandler(null);
        RequestFrequentHandler requestFrequentHandler = new RequestFrequentHandler(loggingHandler);
        if(requestFrequentHandler.process(request)){
            System.out.println("3.正常业务处理");
        }else{
            System.out.println("访问异常");
        }
    }
}
class Request{
    private boolean loggedOn;
    private boolean frequentOk;
    private boolean isPermits;
    private boolean containsSensitiveWords;
    private String requestBody;

    public Request(boolean loggedOn, boolean frequentOk, boolean isPermits, boolean containsSensitiveWords) {
        this.loggedOn = loggedOn;
        this.frequentOk = frequentOk;
        this.isPermits = isPermits;
        this.containsSensitiveWords = containsSensitiveWords;
    }

    public boolean isContainsSensitiveWords() {
        return containsSensitiveWords;
    }

    public boolean isFrequentOk() {
        return frequentOk;
    }

    public boolean isLoggedOn() {
        return loggedOn;
    }

    public boolean isPermits() {
        return isPermits;
    }

    static class RequestBuilder{
        private boolean loggedOn;
        private boolean frequentOk;
        private boolean isPermits;
        private boolean 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;
        }
        public Request build(){
            Request request = new Request(loggedOn, frequentOk, isPermits, containsSensitiveWords);
            return request;
        }
    }
}
//指针
abstract class Handler{
    Handler next;
    public Handler(Handler next) {
        this.next = next;
    }
    public Handler getNext() {
        return next;
    }
    public void setNext(Handler next) {
        this.next = next;
    }
    // 只有返回true 才继续往下执行
    abstract boolean process(Request request);
}
//1.请求频率  访问频率控制
class RequestFrequentHandler extends Handler{
    public RequestFrequentHandler(Handler next) {
        super(next);
    }
    @Override
    boolean process(Request request) {
        System.out.println("1.访问频率控制.");
        if(request.isFrequentOk()){
            //若request的isFrequentOk=tree  getNext()获取下一个节点loggingHandler，父类方法用父类接受 接着进行处理
            Handler loggingHandler = getNext();
            if(null==loggingHandler){
                //到尾结点
                return true;
            }
            //重复调 loggingHandler的process方法 因为next=null 所以返回true 接着向下进行
            if (!loggingHandler.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("2.登录验证.");
        if(request.isFrequentOk()){
            Handler next = getNext();
            if(null==next){
                return true;
            }
            //重复调 next的process方法。
            if(!next.process(request)){
                return false;
            }else{
                return true;
            }
        }
        return false;
    }
}