观察者模式和访问者模式

前言：访问者是主动的，观察者是被动的，但是它们的处理过程都类似责任链模式，都是可以保证顺序性执行。

一：观察者模式 

       定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

/**
 * 观察者接口
 */
public interface Observer {

    void registerObserver(ObserverBehavior o);

    void removeObserver(ObserverBehavior o);

    void notifyObserver();
}

public interface ObserverBehavior {

    void update(String message);
}

/**
 * 模拟微信用户表
 */
public class WechatAccount implements ObserverBehavior{
    WechatAccount(){}

    public WechatAccount(String name, String password) {
        this.name = name;
        this.password = password;
    }


    private String name;
    private String password;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "WechatAccount{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public void update(String message) {
        read(message);
    }

    public void read(String message) {

        System.out.println(name + " 收到推送消息： " + this.toString());
        System.out.println(message);
    }
}

/**
 * @ClassName:      ObserverPatternTest
 * @Description:    观察者模式
 * @Version:        1.0
 * 业务场景：一个微信公众号服务，不定时发布一些消息，关注公众号就可以收到推送消息，取消关注就收不到推送消息
*/
public class ObserverPatternTest implements Observer{
    private static List<ObserverBehavior>  accountList = new ArrayList<>();

    @Override
    public void registerObserver(ObserverBehavior o) {
        accountList.add(o);
    }

    @Override
    public void removeObserver(ObserverBehavior o) {
       if(!CollectionUtils.isEmpty(accountList)){
           accountList.remove(o);
       }
    }

    @Override
    public void notifyObserver() {
        for(int i = 0; i < accountList.size(); i++) {
            ObserverBehavior oserver = accountList.get(i);
            oserver.update("微信服务更新消息：java是世界上最好的语言");
        }
    }

    /**
     * 观察者是被动的，通知者来告知观察者的行为（此处的通知者 粗浅认为和访问者模式中的访问者类似）
     * @param args
     */
    public static void main(String[] args) {
        WechatAccount aaa = new WechatAccount("马云", "123456");
        WechatAccount bbb = new WechatAccount("马化腾", "123456");
        ObserverPatternTest test = new ObserverPatternTest();
        test.registerObserver(aaa);
        test.registerObserver(bbb);
        test.notifyObserver();

    }
} 

二：访问者模式 

       需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。

//访问者接口
public interface Visitor {

    void visitA(Element element);
    void visitB(Element element);
}

public class ConcreteVisitorA implements Visitor{
    @Override
    public void visitA(Element element) {
        System.out.println("元素："+element.getClass());
    }
    @Override
    public void visitB(Element element) {
        System.out.println("元素："+element.getClass());
    }
}

public class ConcreteVisitorB implements Visitor{
    @Override
    public void visitA(Element element) {
        System.out.println("元素："+element.getClass());
    }
    @Override
    public void visitB(Element element) {
        System.out.println("元素："+element.getClass());
    }
}

public abstract class Element {

    abstract void accept(Visitor visitor);
}

public class ConcreteElementOne extends Element{
    public ConcreteElementOne() {
    }

    @Override
    void accept(Visitor visitor) {
        visitor.visitA(this);
    }
}

public class ConcreteElementTwo extends Element{

    public ConcreteElementTwo() {
    }
    @Override
    void accept(Visitor visitor) {
        visitor.visitB(this);
    }
}

public class SwaggerElementObject {
   List<Element> eleList = new ArrayList<Element>();

   public void add(Element element){
       eleList.add(element);
   }
    public  void accept(Visitor visitor){
       for (Element ele : eleList) {
           ele.accept(visitor);
       }
   }
}

/**
 * 访问者模式测试代码
 */
public class VisitorTest {
    public static void main(String[] args) {
        SwaggerElementObject swagger = new SwaggerElementObject();
        swagger.add(new ConcreteElementOne());
        swagger.add(new ConcreteElementTwo());
        //访问者主动发起动作
               swagger.accept(new ConcreteVisitorA());
    }
}