行为型设计模式—chain of responsibility(责任链模式)/observer(观察者模式)/mediator(中介者模式)/iterator(迭代器模式)

一、chain of responsibility(责任链模式)

(1)、思想

对数据的处理形成一条链条,一个节点处理完成之后再由下个节点进行处理。

(2)、步骤

 1. 声明fifler接口,声明fifter方法 
 2. 声明fifter接口实现类,实现fifter方法
 3. 声明FilterChain类,对各个fifter实现对象进行管理,包括增加/删除/索引管理等
 4. FilterChain类里面维护成员变量List<Ififter> fifterList,和index,dofifter方法里面
    通过这两个成员变量判断是否是最后一个fifter对象. 
    如果不是则取出当前的fifter对  象并调用其dofifter方法
    
    fifter接口实现类的dofifter方法里面先对request数据进行处理,
    然后通过调用FilterChain类的dofifter方法进行递归操作,
    先将方法递出去,这样就可以保证按照链条的顺序先对request进行处理,
    然后再由最后一个fifter对象response进行处理,从最后一个到第一个fifter返回。

	重点就在于fifter接口实现类里面的dofifter方法要通过传入的FilterChain参数
	调用FilterChain的dofifter方法,而FilterChain的dofifter方法里面又会通过当前
	下标取出当前应该执行的Filter接口实现类对象调用其dofifter方法。
	这样就可以实现递归操作。

（3）、代码

//过滤接口,声明过滤方法
public interface Ififter {
    public boolean doFifter(Request request, Response response, FilterChain filterChain);
}

//过滤器,过滤器里面先处理请求,然后调用过滤器链对象的dofifter方法执行下一个过滤器的doFifter,
//递归调用,最后再处理响应数据
public class fifter1 implements Ififter{

    @Override
    public boolean doFifter(Request request, Response response, FilterChain filterChain) {
        request.msg=request.msg.replaceAll("\\[","").replaceAll("]","");
        filterChain.dofifter(request,response);
        response.msg+="-";
        return true;
    }
}

//过滤器,过滤器里面先处理请求,然后调用过滤器链对象的dofifter方法执行下一个过滤器的doFifter,
//递归调用,最后再处理响应数据
public class fifter2 implements Ififter{

    @Override
    public boolean doFifter(Request request, Response response, FilterChain filterChain) {
        request.msg=request.msg.replaceAll("\\{","").replaceAll("}","");
        filterChain.dofifter(request,response);
        response.msg+="-";
        return true;
    }
}

public class Request {
    public String msg;
}

public class Response {
    public String msg;
}

//责任链对象,声明add方法,往静态成员变量链表里面加fifter对象
//声明dofifter方法,判断当前index是否等于链表长度,不等于就执行对应的fifter对象的doFifter方法
//重点在于调用一次dofifter方法,链表计数器要自增一次,将当前责任链对象传入到fifter对象的doFifter中去
//在fifter对象的doFifter中去处理请求,然后用递归方式调用下一个fifter对象,递归完成之后,请求链条已经执行完了,
//然后再从最后一个fiter处理响应,这样就形成了请求和响应的责任链。
public class FilterChain {

    private static List<Ififter> fifterList=new LinkedList<>();
    private static Integer index=0;

    public FilterChain add(Ififter ififter){
        fifterList.add(ififter);
        return this;
    }

    public boolean dofifter(Request request, Response response){
        if (index==fifterList.size()) return false;
         Ififter ififter=fifterList.get(index);
         index++;
         return ififter.doFifter(request,response,this);
    }
}

public class chainTest {

    public static void main(String[] args) {

        Request request=new Request();
        Response response=new Response();
        request.msg="sdsffs{1}[2]";
        response.msg="";

        Ififter ififter1=new fifter1();
        Ififter ififter2=new fifter2();
        FilterChain filterChain=new FilterChain();
        filterChain.add(ififter1).add(ififter2);
        filterChain.dofifter(request,response);

        System.out.println(request.msg);
        System.out.println(response.msg);
    }
}

二、observer(观察者模式)

(1)、思想

目标对象维护观察者的添加/删除/方法执行,目标方法里面执行观察者的方法,
达到观察者监控目标方法的目的。
观察者对象的方法通过事件参数来判断执行什么逻辑。

(2)、步骤

 1. 声明事件抽象类 	
 2. 声明具体事件类,继承事件抽象类 	
 3. 声明观察者接口
 4. 声明观察者接口实现类,重写接口方法,通过事件参数在方法内部执行不同的逻辑。
 5. 声明目标类,通过add方法和成员变量维护观察者列表,在目标方法里面循环调用观察者方法。

(3)、代码

//事件抽象类
public abstract class  IEvent {

    private String eventName;

    public IEvent(String eventName) {
        this.eventName = eventName;
    }

    public String getEventName() {
        return eventName;
    }
}

public class Event1 extends IEvent{

    public Event1(String eventName) {
        super(eventName);
    }
}

//观察者接口
public interface IObserver {

    //观察者被触发的方法
    public void obsExec(IEvent event);
}

//观察者1
public class Observer1 implements IObserver{

    @Override
    public void obsExec(IEvent event) {
        if (event instanceof Event1){
            System.out.println(event.getEventName()+"触发");
        }
    }
}
//被观察者
public class Target {

    //观察者集合
    private static List<IObserver> observerList=new ArrayList<>();
    //添加观察者
    public Target add(IObserver observer){
        observerList.add(observer);
        return this;
    }
    //被监视的方法
    public void exec(IEvent event){
        System.out.println("被观察者说话");
        for (IObserver o:observerList){
            //触发观察者方法
            o.obsExec(event);
        }
    }
}

//观察者模式
//声明观察者,观察者里面声明方法,在被观察者的某个方法被调用时触发,
// 方法参数为事件抽象类,在观察者的方法里面去判断不同的事件执行不同的逻辑
//声明被观察者,创建添加观察者的add方法,和与观察者联动的方法。
public class obsTest {

    public static void main(String[] args) {
        IEvent event=new Event1("事件1");
        IObserver observer=new Observer1();
        Target target=new Target();
        target.add(observer);

        target.exec(event);

    }
}

三、mediator(中介者模式)

(1)、思想

各个复杂的对象都集中在中介者对象里面,由中介者来维护各个对象之间的通信。
spring的ioc本质上就是一种中介者模式,springBean都往中介者上注册,
要调用的时候之间通过中介者对象来取。

(2)、步骤

 1. 声明中介者接口,
 2. 声明中介者通信接口方法,参数为参与者抽象类 	
 3. 声明参与者抽象类,通过构造方法持有中介者,
 4. 声明公有方法返回中介者
 5. 声明多个参与者子类,继承参与者抽象类,通过构造方法往父类构造方法传递参数,
    已保证持有中介者,通过调用父类的返回中介者方法调用中介者对象的通信方法。
 6. 声明中介者实现类,通过set方法持有所有的参与者对象,
    在通信方法里面通过判断参与者具体类型实现不同的通信逻辑(参与者之间的通信)

(3)、代码

//参与者抽象类
public abstract class AbsColleague {

    //每个参与者都需要持有中介者
    private IMediator iMediator;

    public AbsColleague(IMediator iMediator) {
        this.iMediator = iMediator;
    }

    //获取中介者
    public IMediator getiMediator() {
        return iMediator;
    }
}
//中介者抽象接口
public interface IMediator {

    //抽象方法,用于参与者之间通信
    public void changed(AbsColleague colleague);

}
//具体参与者1
public class Colleague1 extends AbsColleague{

    //参与者持有中介者
    public Colleague1(IMediator iMediator) {
        super(iMediator);
    }

    //参与者之间的通信方法
    public void operation(){
        //在需要跟其他同事通信的时候，通知调停者对象
        getiMediator().changed(this);
    }

    //参与者自身的业务方法
    public String getData(){
        String res="参与者1的数据";
        return res;
    }

}
public class Colleague2 extends AbsColleague{

    //参与者持有中介者
    public Colleague2(IMediator iMediator) {
        super(iMediator);
    }

    //参与者之间的通信方法
    public void operation(){
        //在需要跟其他同事通信的时候，通知调停者对象
        getiMediator().changed(this);
    }

    //参与者自身的业务方法
    public void print(String data){
        System.out.println("参与者2收到"+data);
    }
}
//中介者实现类
public class MediatorImpl implements IMediator{

    //持有所有参与者
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    //用于参与者直接的通信
    @Override
    public void changed(AbsColleague colleague) {

        if(colleague instanceof Colleague1){
            String data=((Colleague1) colleague).getData();
            colleague2.print(data);
        }
    }
}

//中介者模式,主要用于用一个中介对象,管理各个参与者之间的通信,各个参与者之间可以解耦合。
//1、声明中介接口:   声明一个change方法,用于各个参与者之间的通信,各个参与者之间的通信要通过这个方法来触发。
//2、声明中介具体类:   声明各个参与者对象的set方法,用于持有各个参与者
//                  实现接口方法change,里面实现逻辑(不同的参与者对象,实现不同的逻辑(与另外那个参与者进行交互))。
//3、声明参与者抽象类: 持有中介者对象,声明获取中介者对象的方法。
//4、声明参与者具体类: 声明于其它各个参与者通信的方法,方法里面就是调用中介者对象的声明一个change方法。
//5、各个参与者有一些自己的逻辑方法,用于接收或者返回数据。
public class MediatorTest {

    public static void main(String[] args) {

        //声明中介对象
        MediatorImpl mediator=new MediatorImpl();
        //声明参与者1
        Colleague1 colleague1=new Colleague1(mediator);
        //声明参与者2
        Colleague2 colleague2=new Colleague2(mediator);
        //中介者注入参与者
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        //参与者1调用通信方法
        colleague1.operation();

    }

}

四、iterator(迭代器模式)

(1)、思想

用于变量集合的设计模式,就是在容器内部实现遍历方法,
所有的数据结构都是基于链表和数组的物理结构上扩展的逻辑结构。

重点在于容器内部要维护长度和当前指针等成员变量,
对容器的元素添加和获取等操作都依赖于都这些成员变量的操作。

在每个容器内部都自己实现一个迭代方法,迭代方法内部返回一个迭代实现类,
客户端就可以通过这个迭代实现类对象来对容器进行迭代操作。

迭代实现类里面主要是实现hasnext和next方法,维护下标,通过构造方法持有容器对象。

(2)、步骤

 1. 声明迭代器接口,声明hasnext和next方法 	
 2. 实现迭代器接口,重写hasnext和next方法,通过构造方法持有容器对象
 3. 容器对象里面创建返回迭代器的方法,就是每个容器返回不同的迭代器接口实现类,
    这样就可以实现没个容器的迭代器都不同。

(3)、代码

//集合接口
public interface ICollection {

    //返回迭代器
    public Iterator iterator();
}

//具体的集合类
public class ArrayList_ implements ICollection{

    //长度
    private  Integer size=0;
    //指针
    private  Integer index=0;

    //底层数组
    private Node_ [] node_s=new Node_[10];

    @Override
    public Iterator iterator() {
        return new ArrayList_Iterator(this);
    }

    //往数组添加元素
    public void add(Node_ node_){
        node_s[index]=node_;
        index++;
        size++;
    }

    public Node_ get(int index){
        return node_s[index];
    }

    public  Integer getSize() {
        return size;
    }
}
//元素类
public class Node_<E> {

    private E data;


    public Node_(E data) {
        this.data = data;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }
}

//迭代器接口
public interface Iterator {

    //是否有下个节点
    public boolean hasNext();
    //获取下一个节点
    public Node_ next();
}
//具体的集合迭代器对象,主要是实现hasnext和next方法,维护下标
public class ArrayList_Iterator implements Iterator{

    private  Integer index=0;

    private  ArrayList_ arrayList_;

    public ArrayList_Iterator(ArrayList_ arrayList_) {
        this.arrayList_ = arrayList_;
    }

    @Override
    public boolean hasNext() {
        return arrayList_.getSize()>0;
    }

    @Override
    public Node_ next() {
        Node_ e=arrayList_.get(index);
        index++;
        return e;
    }
}

//迭代器模式,声明迭代器接口,每种集合的iterator()都返回对应的迭代器实现对象
public class iteratorTest {

    public static void main(String[] args) {
        ArrayList_ arrayList_=new ArrayList_();
        Node_ node1_=new Node_("1");
        Node_ node_2=new Node_("2");
        arrayList_.add(node1_);
        arrayList_.add(node_2);
        Iterator iterator=arrayList_.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next().getData());
        }
    }
}