自学日记：设计模式-观察者模式、监听器模式

为什么使用观察者模式和监听器模式？
当方法体内的代码在执行的时候，是面向过程从上往下每行代码一次执行。当执行到某一步骤的时候，我们需要需要其它做额外的事情来配合完成，或者说我们需要触发其它另外的一个操作我们会使用到监听或者观察者模式！
先上代码再解释：

1、观察者模式

//观察者类
public class AListener{

	//当观察者发现被监听者的特定操作后，需要执行的逻辑
    public void doEvent() {
        System.out.println("观察者逻辑");
    }
}

//被监听者类
public class DoSomeThing {

	//注册众多观察者
    private List<Listener> aListener=new ArrayList<Listener>();

	//也可以是只有一个观察者
	private Listener listener；
	
    public DoSomeThing() {
    }

	//注册方法
    public void registerListener(Listener listener){
        this.aListener.add(listener);
        this.listener=listener;
    }

	//移除观察者
    public void removeListener(Listener listener){
        this.aListener.remove(listener);
        this.listener=null;
    }
	
	//给所有的已经注册的观察者发送信息
    private void notifyMsg(){
        for (Listener listener:this.aListener){
            listener.doEvent();
        }
    }

	//被观察者的某个方法，这里可以特定理解为被观察者观察的特定操作
    void doSome(){
        System.out.println("do something");
        notifyMsg();
    }

	//测试
    public static void main(String[] args) {
        DoSomeThing someThing=new DoSomeThing();
        someThing.registerListener(new AListener());
        someThing.doSome();
    }
}

我们可以采用逆向思维理解：其实再我们刚学习编程的时候都是以面向过程的方法来写的，粗略一看，干嘛要写这么复杂呢？？我直接再void doSome（）方法中将doEvent（）方法体内的逻辑写在下面依次执行就可以了嘛 ，或者将各个观察者的doEvent（）方法封装在被观察者内，当doSome（）方法执行到特定步骤的时候调用不就完了嘛！！
但是Java是面向对象的，这样写违背了java的相关基本原则，大家如果看到这里可以复习一下，我自己也需要复习一下。小狗有汪汪叫、撒尿抬腿、吃屎的行为，作为人不能这样子吧！其次写在一堆也不利于代码的复用！所以在小狗汪汪叫的时候，它通知了人可能有小偷，而人的行为是抓小偷并报警！！这里人是作为观察者，小狗作为被观察者！

监听器模式和观察者模式类似，只是监听器是基于不同的事件来触发各种不同的操作的。不在多解释，上代码

import java.util.EventListener;
import java.util.EventObject;

//监听器类
public class AListener implements EventListener {

    public void report(EventObject event){
    	if (event.equals("something 1")){
            //do some 1
        }else if (event.equals("something 2")){
            //do some 2
        }
        System.out.println("发生了事件："+event.toString());
    }
}

import java.util.EventObject;

//事件类
public class Event extends EventObject {
    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public Event(Object source) {
        super(source);
    }
}

public class DoEvent {

    public AListener listener;

    public DoEvent(AListener listener){
        this.listener=listener;
    }

    public void doWork(EventObject object){
        System.out.println("被监听对象工作了");
        listener.report(object);
    }

    public static void main(String[] args) {
        DoEvent doEvent=new DoEvent(new AListener());
        doEvent.doWork(new Event("开始工作"));

    }
}

在诸多框架中也使用到了监听器模式，注入spring 、tomcat等等！