6,设计模式之观察者模式

什么事观察者模式
在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖他的对象会收到通知自动更新，其实就是发布订阅模式，发布者发布消息，订阅者获取消息，订阅了就能收到消息，没订阅收不到消息。
Spring封装时间监听
例如用户注册成功后，会发送邮件和短信

package com.taotao.observer.entity;import lombok.Data;import org.springframework.context.ApplicationEvent;@Datapublic class MsgEntity extends ApplicationEvent {    // 手机号码    private String phone;    // 邮件    private String email;    // 微信openid    private String weChatOpenId;    /**     * 钉钉openid     */    private String dindinOpenId;    public MsgEntity(Object source, String phone, String email, String weChatOpenId, String dindinOpenId) {        super(source);        this.phone = phone;        this.email = email;        this.weChatOpenId = weChatOpenId;        this.dindinOpenId = dindinOpenId;    }    @Override    public String toString() {        return "MsgEntity{" +                "phone='" + phone + '\'' +                ", email='" + email + '\'' +                ", weChatOpenId='" + weChatOpenId + '\'' +                ", dindinOpenId='" + dindinOpenId + '\'' +                '}';    }}

package com.taotao.observer.listener;import com.taotao.observer.entity.MsgEntity;import lombok.extern.slf4j.Slf4j;import org.springframework.context.ApplicationListener;import org.springframework.scheduling.annotation.Async;import org.springframework.stereotype.Component;/** * @Author: wangjin * @CreateTime: 2022-07-02  22:07 */@Slf4j@Componentpublic class TextMessageListener implements ApplicationListener {    @Override    @Async    public void onApplicationEvent(MsgEntity event) {        log.info("<发送短信:{}>",event.toString());    }}

package com.taotao.observer.listener;import com.taotao.observer.entity.MsgEntity;import javafx.application.Application;import lombok.extern.slf4j.Slf4j;import org.springframework.context.ApplicationListener;import org.springframework.scheduling.annotation.Async;import org.springframework.stereotype.Component;/** * @Author: wangjin * @CreateTime: 2022-07-02  22:05 */@Slf4j@Componentpublic class WeChatMessageListener implements ApplicationListener {    @Async    @Override    public void onApplicationEvent(MsgEntity event) {        int i=1/0;        //发送微信        log.info("<发送微信:{}>",event.toString());    }}

package com.taotao.observer.controller;import com.taotao.observer.entity.MsgEntity;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/** * @Author: wangjin * @CreateTime: 2022-07-02  22:10 */@RestController@Slf4jpublic class ObserverController {    @Autowired    private ApplicationContext applicationContext;    @RequestMapping("/register")    public String register(){          log.info("register。。。。。。");        // 发送短信、发送邮件、发送微信公众号        // sendMsg();        // sendEmail();        // sendWechatTemplate();        MsgEntity msgEntity=new MsgEntity(this,"18547554252","552@qq.com","ws777","sdss5470");        applicationContext.publishEvent(msgEntity);        return "ok";    }}

package com.taotao;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.scheduling.annotation.EnableAsync;/** * @Author: wangjin 观察者模式 * @CreateTime: 2022-07-02  21:57 */@SpringBootApplication@EnableAsyncpublic class AppObserver {    public static void main(String[] args) {        SpringApplication.run(AppObserver.class);    }}

观察者模式应用场景
Zookeeper事件通知节点，消息订阅通知，安卓开发时间注册，分布式注册中心。
1，抽象被观察者角色：也是一个抽象主题，它把所有对观察者对象的引用保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
2，抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
3，具体被观察者角色，也就是一个具体的主题，在集体主题内部改变状态的时候，所有登记过的观察者发出通知。
4，具体观察者角色：实现抽象者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

使用观察者群发邮件、短信
抽象观察者

package com.taotao.observer1;/** * @Author: wangjin * @CreateTime: 2022-07-03  10:35 */public interface AbstractSubject {    /**     * 新增观察者对象存入到集合     * @param observer     */    void addObserver(Observer observer);    /**     *删除某个观察者对象     * @param observer     */    void delObserver(Observer observer);    /**     *通知所有的观察者     * @param observer     */    void notifyAll(String message);}

package com.taotao.observer1;import lombok.extern.slf4j.Slf4j;/** * @Author: wangjin * @CreateTime: 2022-07-03  10:29 */public interface Observer {    /**     * 观察者方法     */    void update(String message);}

package com.taotao.observer1.impl;import com.taotao.observer1.AbstractSubject;import com.taotao.observer1.Observer;import java.util.ArrayList;import java.util.List;/** * @Author: wangjin * @CreateTime: 2022-07-03  10:38 */public class MsgSubject  implements AbstractSubject {    private List observers=new ArrayList<>();    @Override    public void addObserver(Observer observer) {        observers.add(observer);    }    @Override    public void delObserver(Observer observer) {        observers.remove(observer);    }    @Override    public void notifyAll(String message) {        observers.forEach(o->{            o.update(message);        });    }}

package com.taotao.observer1.impl;import com.taotao.observer1.Observer;import lombok.extern.slf4j.Slf4j;/** * @Author: wangjin * @CreateT * ime: 2022-07-03  10:31 */@Slf4jpublic class TextMessageObserver implements Observer {    @Override    public void update(String message) {        log.info("<接受到数据，开始发送短信>");    }}

package com.taotao.observer1.impl;import com.mysql.cj.log.Log;import com.taotao.observer1.Observer;import lombok.extern.slf4j.Slf4j;/** * @Author: wangjin * @CreateT * ime: 2022-07-03  10:31 */@Slf4jpublic class WeChatObserver  implements Observer {    @Override    public void update(String message) {        log.info("<接受到数据，开始发送微信模板>");    }}

package com.taotao.observer1;import com.taotao.observer1.impl.MsgSubject;import com.taotao.observer1.impl.TextMessageObserver;import com.taotao.observer1.impl.WeChatObserver;/** * @Author: wangjin * @CreateTime: 2022-07-03  10:54 */public class Test1 {    public static void main(String[] args) {        //将观察者 存入到对象集合        Observer  observer1=new TextMessageObserver();        Observer  observer2=new WeChatObserver();        MsgSubject msgSubject=new MsgSubject();        msgSubject.addObserver(observer1);        msgSubject.addObserver(observer2);        //通知给所有的观察者        msgSubject.notifyAll("taotao");    }}

jdk自带封装的观察者

1,Observable类追踪所有的观察者,并通知他们

package com.taotao.jdk;import java.util.Observable;public class MessageObServable extends Observable {    @Override    public void notifyObservers(Object obj) {        // 1.改变数据        setChanged();        // 2.通知所有观察者改变        super.notifyObservers(obj);    }}

package com.taotao.jdk;import lombok.extern.slf4j.Slf4j;import java.util.Observable;import java.util.Observer;/** * @Author: wangjin * @CreateTime: 2022-07-03  12:08 */@Slf4jpublic class JdkMessageObServable implements Observer {    @Override    public void update(Observable o, Object arg) {        //Observable o 获得主题        //Object arg 获得对象          log.info("<接收到数据，开始发送短信>msg:{}",arg);    }}

package com.taotao.jdk;import lombok.extern.slf4j.Slf4j;import java.util.Observable;import java.util.Observer;/** * @Author: wangjin * @CreateT * ime: 2022-07-03  10:31 */@Slf4jpublic class JdkTextMessageObserver implements Observer {    @Override    public void update(Observable o, Object arg) {        //Observable o 获得主题        //Object arg 获得对象        log.info("<接收到数据，开始发送消息>msg:{}",arg);    }}

package com.taotao.jdk;/** * @Author: wangjin * @CreateTime: 2022-07-03  12:20 */public class Test01 {    public static void main(String[] args) {        MessageObServable messageObServable=new MessageObServable();        messageObServable.addObserver(new JdkMessageObServable());        messageObServable.addObserver(new JdkWeChatObserver());        messageObServable.notifyObservers("hello");    }}