07.观察者模式

JAVA白名单

已于 2022-02-24 10:54:28 修改

阅读量201

点赞数

分类专栏： 001.设计模式文章标签：观察者模式

于 2022-02-24 10:53:25 首次发布

本文链接：https://blog.csdn.net/qq_26477149/article/details/123106678

版权

001.设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.什么是观察者模式

在对象中定义了一对多的依赖，当一个对象发生改变时，通知给其它对象

2.观察者角色

抽象主题

具体主题

抽象观察者

具体观察者

3.应用场景

消息订阅通知

4.观察者模式实现

链接：https://pan.baidu.com/s/1glb0TXdFvK-XBSfoQ6M-5A
提取码：idmu

1）抽象主题

import com.demo.observer.ObServer;

/**
 * 抽象主题
 */
public interface AbstractSubject {

    /**
     * 添加观察者  注册观察者
     */
    void addObServer(ObServer obServer);

    /**
     * 移除观察者
     * @param obServer
     */
    void removeServer(ObServer obServer);

    /**
     * 通知消息
     */
    void notifyObServer(String message);
}

2）具体主题

import com.demo.observer.ObServer;
import com.demo.subject.AbstractSubject;

import java.util.ArrayList;
import java.util.List;

/**
 * 具体主题
 */
public class WeChatSubject implements AbstractSubject {

    private List<ObServer> obServerList = new ArrayList<ObServer>();

    /**
     * 添加观察者  注册观察者
     */
    public void addObServer(ObServer obServer) {
        obServerList.add(obServer);
    }

    /**
     * 移除观察者
     * @param obServer
     */
    public void removeServer(ObServer obServer) {
        obServerList.remove(obServer);
    }

    /**
     * 通知消息
     */
    public void notifyObServer(String message) {
        System.out.println("开始设置微信群发消息：" + message);
        // 调用观察者通知方案
        for (int i = 0; i < obServerList.size(); i++) {
            ObServer obServer = obServerList.get(i);
            //调用观察者通知方法
            obServer.update(message);
        }
    }
}

3）抽象观察者

/**
 * 抽象观察者
 */
public interface ObServer {

    /**
     * 通知观察者消息
     * @param message
     */
    void update(String message);

}

4）具体观察者

import com.demo.observer.ObServer;

/**
 * 具体观察者
 */
public class UserObServer implements ObServer {

    private String name;

    public UserObServer(String name) {
        this.name = name;
    }

    public void update(String message) {
        System.out.println(name + ",收到微信服务通知的消息:" + message);
    }
}

5）测试

import com.demo.observer.impl.UserObServer;
import com.demo.subject.AbstractSubject;
import com.demo.subject.impl.WeChatSubject;

public class Test001 {

    public static void main(String[] args) {

        // 1.创建具体的在主题
        AbstractSubject abstractSubject = new WeChatSubject();
        // 2.开始注册或者添加观察者
        abstractSubject.addObServer(new UserObServer("向前"));
        abstractSubject.addObServer(new UserObServer("向后"));
        // 3.群发消息
        abstractSubject.notifyObServer("你好");

    }
}

5.观察者模式-基于jdk实现

链接：https://pan.baidu.com/s/1cn2Tmm00vJoaHuOMlwNF1A
提取码：t2xu

1）具体主题

import java.util.Observable;

/**
 * 具体主题
 */
public class MessageObServable extends Observable {

    @Override
    public void notifyObservers(Object arg) {
        // 1.修改状态为可以群发
        setChanged();
        // 2.调用父类的notifyObservers 群发消息
        super.notifyObservers(arg);
    }
}

2）具体观察者

import java.util.Observable;
import java.util.Observer;

/**
 * 具体观察者
 */
public class EmailObServer implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("用户下单成功,发送邮件提醒内容:" + arg);
    }
}

import java.util.Observable;
import java.util.Observer;

/**
 * 具体观察者
 */
public class SmsObServer implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("用户下单成功,发送短信提醒内容:" + arg);
    }
}

import java.util.Observable;
import java.util.Observer;

/**
 * 具体观察者
 */
public class WechatObServer implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("用户下单成功,发送微信体醒内容:" + arg);
    }
}

3）测试

import com.demo.observer.EmailObServer;
import com.demo.observer.SmsObServer;
import com.demo.observer.WechatObServer;
import com.demo.subject.MessageObServable;

import java.util.Observable;

public class Test {

    public static void main(String[] args) {
        // 1.创建具体的主题
        Observable observable = new MessageObServable();
        // 2. 注册观察者
        observable.addObserver(new SmsObServer());
        observable.addObserver(new WechatObServer());
        observable.addObserver(new EmailObServer());
        // 3.群发消息
        observable.notifyObservers("哈哈");
    }
}

5.观察者模式-基于spring实现

链接：https://pan.baidu.com/s/18tvI_nsG6KyhsxILcTAJ_Q
提取码：9v6k

1）pom依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.11.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

2）主题

import com.alibaba.fastjson.JSONObject;
import org.springframework.context.ApplicationEvent;

public class OrderMessageEvent extends ApplicationEvent {

    /**
     * 群发消息的内容
     */
    private JSONObject jsonObject;

    public JSONObject getJsonObject() {
        return jsonObject;
    }

    public OrderMessageEvent(Object source, JSONObject jsonObject) {
        super(source);
        this.jsonObject = jsonObject;
    }
}

3）具体观察者

import com.demo.event.OrderMessageEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class EmailListener implements ApplicationListener<OrderMessageEvent> {

    @Override
    @Async
    public void onApplicationEvent(OrderMessageEvent event) {
        System.out.println(Thread.currentThread().getName() + "开始发送邮件消息内容:" + event.getJsonObject().toJSONString());
    }
}

import com.demo.event.OrderMessageEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class SmsListener implements ApplicationListener<OrderMessageEvent> {

    @Override
    @Async
    public void onApplicationEvent(OrderMessageEvent event) {
        System.out.println(Thread.currentThread().getName() + "开始短信消息内容:" + event.getJsonObject().toJSONString());
    }
}

4）控制层

import com.alibaba.fastjson.JSONObject;
import com.demo.event.OrderMessageEvent;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class OrderController {

    @Resource
    private ApplicationContext applicationContext;

    @RequestMapping("/sendMsg")
    public String sendMsg() {
        //1.定义发送消息内容
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("email", "1209536385@qq.com");
        jsonObject.put("phone", "18159774275");
        jsonObject.put("text", "测试");
        OrderMessageEvent orderMessageEvent = new OrderMessageEvent(this, jsonObject);
        applicationContext.publishEvent(orderMessageEvent);
        return "success";
    }
}

5）启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class AppObServer {

    public static void main(String[] args) {
        SpringApplication.run(AppObServer.class);
    }
}

6）测试

http://localhost:8080/sendMsg