美文网首页
6,设计模式之观察者模式

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

作者: 滔滔逐浪 | 来源:发表于2022-06-22 21:38 被阅读0次

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

package com.taotao.observer.entity;

import lombok.Data;
import org.springframework.context.ApplicationEvent;

@Data
public 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
@Component
public class TextMessageListener implements ApplicationListener<MsgEntity> {
    @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
@Component
public class WeChatMessageListener implements ApplicationListener<MsgEntity> {
    @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
@Slf4j
public 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
@EnableAsync
public 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<Observer> 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
 */
@Slf4j
public 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
 */
@Slf4j
public 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;

/**
 * @author 余胜军
 * @ClassName MessageObServable
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
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
 */
@Slf4j
public 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
 */
@Slf4j
public 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");
    }
}

相关文章

网友评论

      本文标题：6,设计模式之观察者模式

      本文链接：https://www.haomeiwen.com/subject/mwnuvrtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|6,设计模式之观察者模式|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！