常用设计模式：模板方法模式、观察者模式、责任链模式

模板方法模式、观察者模式、责任链模式

模板方法模式

定义：定义一个操作的算法骨架，而将一些步骤延迟到子类中。Template Method 使得子类可以不改变一个算法的结构即可重定义该算法的某些 特定步骤

//定义一个模板
public abstract class AbstractClass {
	//定义模板方法 一些前置步骤或者必要性步骤 有模板方法完成
	public void  operation(){
		System.out.println(" pre ... ");
		System.out.println(" step1 ");
		System.out.println(" step2 ");
		templateMethod();
		// .... 一些后续的步骤也可以有模板方法完成
	}

	//用户的扩展点，不同的用户在该方法做具体的实现
	abstract protected void templateMethod();
}

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

class SubCalss1 extends AbstractClass{
	@Override
	protected void templateMethod() {
		System.out.println("SubClass1 executed . ");
	}
}

测试：

public class Test {
    public static void main(String[] args) {
        AbstractClass subCalss = new SubCalss();
        subCalss.operation();
        System.out.println("-----------------");
        AbstractClass subCalss1 = new SubCalss1();
        subCalss1.operation();

    }
}

应用场景
1.当你想让客户端只扩展算法的特定步骤，而不是整个算法或其结构 时，请使用Template Method模式。
2.当你有几个类包含几乎相同的算法，但有一些细微的差异时，请使用 此模式。

优点：
1.你可以让客户端只覆盖大型算法的某些部分，从而减少算法其他部分 发生的更改对它们的影响。
2.你可以将重复的代码拖放到超类中。

观察者模式

定义：定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新

//定义一个主题
public class Subject {
	private List<Observer> container = new ArrayList<>();

	public void addObserver(Observer observer){
		container.add(observer);
	}
	public void remove(Observer observer){
		container.remove(observer);
	}
	public void notifyAllObserver(Object obj){
		for (Observer item :container) {
			item.update(obj);
		}

	}
}

//定义观察者接口
public interface Observer {
	void update(Object obj);
}
//具体的观察者
public class Task implements Observer{
	@Override
	public void update(Object obj) {
		System.out.println("task receive:"+obj);
	}
}

class Task1 implements Observer{
	@Override
	public void update(Object obj) {
		System.out.println("task1 receive:"+obj);
	}
}

测试：

public class Test {
	public static void main(String[] args) {
		Subject subject = new Subject();
		subject.addObserver(new Task());
		subject.addObserver(new Task1());
		subject.notifyAllObserver("xxxx");
	}
}

应用场景：
当更改一个对象的状态可能需要更改其他对象，并且实际的对象集事先 未知或动态更改时，请使用观察者模式。

优点：
1.符合开闭原则
2.可以在运行时建立对象之间的关系

责任链模式

定义：为请求创建了一个接收者对象的链。
比如说有一个请求，经过 请求频率、登录认证、访问权限、敏感词过滤等步骤才能传递到后端。
如果把代码都写进一个方法里面

void process{
//	请求频率
//	登录认证
//	访问权限
//	敏感词过滤
...
}

那么后续还要增加 其他认证条件就需要修改process的代码，这样就会影响到请求频率、登录认证、访问权限、敏感词过滤等步骤的代码。同时如果其他地方需要使用到敏感词过滤这个功能，也不能很好的复用。
因此采用责任链模式进行开发

//定义一个请求
class Request{
    //判断是否通过过滤
    private boolean loggedOn;
    private boolean frequentOk;
    private boolean isPermits;
    private boolean containsSensitiveWords;

    private 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;

        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;
        }

    }

    public boolean isLoggedOn() {
        return loggedOn;
    }

    public boolean isFrequentOk() {
        return frequentOk;
    }

    public boolean isPermits() {
        return isPermits;
    }

    public boolean isContainsSensitiveWords() {
        return containsSensitiveWords;
    }
}

//定义处理抽象父类
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;
    }
    abstract boolean process(Request request);

}
//具体handler的实现
//请求频率验证
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;
    }
}

测试：

public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        Request request=new Request.RequestBuilder().frequentOk( true ).loggedOn( true ).build();
        RequestFrequentHandler requestFrequentHandler=new RequestFrequentHandler( new LoggingHandler( null ) );

        if (requestFrequentHandler.process( request )) {

            System.out.println(" 正常业务处理");
        }else{
            System.out.println(" 访问异常");
        }

    }
}

应用场景： 一个请求的处理需要多个对象当中的一个或几个协作处理
优点:
1.请求的发送者和接受者解耦
2.可以控制执行顺序
3.符合开闭原则和单一职责原则