设计模式-观察者模式

设计模式之观察者模式 本文先是介绍了观察者模式,给出定义、重要的角色、具体的代码实现。然后介绍了EventBus,从使用到刨析原理。最后我们又简单地对照了一下观察者模式和监听器模式。 阅读详情

观察者模式

它有一种广为人知的名字发布订阅模式

1、简介:

  • 对象之间存在一对多的依赖,当一个对象(一)状态发生改变时,其所依赖的对象(观察者对象)会自动收到通知。
  • 被观察者:被依赖的对象
  • 行为型设计模式
  • 观察者:依赖的对象
  • 监听器基于此原理
  • 在实际的项目开发中,这两种对象的称呼是比较灵活的,有各种不同的叫法,比如:Subject-Observer、Publisher-Subscriber、Producer-Consumer、EventEmitter-EventListener、Dispatcher-Listener。
  • 实现机制;
    1. 被观察类:这个类中有一个 ArrayList 存放观察者们,除此以外还应有类状态和设置和获取状态的方法,状态改变时通知所有观察者,
    2. 观察者类可以有个抽象类,所有的观察者类继承这个抽象类,观察者类有它要观察的对象。
  • 多种实现方式:
    1. 进程内的
      • 同步阻塞(BIO):观察者和被观察者代码再同一个线程内执行,被观察者一直阻塞,直到所有的观察者代码都执行完成之后,才执行后续的代码。
      • 异步非阻塞
    2. 跨进程:PRC调用或者基于消息队列来实现
      在这里插入图片描述

2、模板代码:

2.1、demo1

//被观察者
public interface Subject {
  void registerObserver(Observer observer);
  void removeObserver(Observer observer);
  void notifyObservers(Message message);
}
public interface Observer {
  void update(Message message);
}
//被观察者 存放观察者集合,唤醒通知观察者方法,注册、移除观察者、
public class ConcreteSubject implements Subject {
  private List<Observer> observers = new ArrayList<Observer>();
  @Override
  public void registerObserver(Observer observer) {
    observers.add(observer);
  }
  @Override
  public void removeObserver(Observer observer) {
    observers.remove(observer);
  }
  @Override
  public void notifyObservers(Message message) {
    for (Observer observer : observers) {
      observer.update(message);
    }
  }
}
public class ConcreteObserverOne implements Observer {
  @Override
  public void update(Message message) {
    //TODO: 获取消息通知,执行自己的逻辑...
    System.out.println("ConcreteObserverOne is notified.");
  }
}
public class ConcreteObserverTwo implements Observer {
  @Override
  public void update(Message message) {
    //TODO: 获取消息通知,执行自己的逻辑...
    System.out.println("ConcreteObserverTwo is notified.");
  }
}
public class Demo {
  public static void main(String[] args) {
    ConcreteSubject subject = new ConcreteSubject();
    subject.registerObserver(new ConcreteObserverOne());
    subject.registerObserver(new ConcreteObserverTwo());
    subject.notifyObservers(new Message());
  }
}
public class UserController {
  private UserService userService; // 依赖注入
  private PromotionService promotionService; // 依赖注入
  public Long register(String telephone, String password) {
    //省略输入参数的校验代码
    //省略userService.register()异常的try-catch代码
    long userId = userService.register(telephone, password);
    promotionService.issueNewUserExperienceCash(userId);
    return userId;
  }
}

2.2、用户注册

//具体服务类
public class NotificationService {
    public void sendInboxMessage(Long userId,String msg){
        System.err.println("通知观察者在发送欢迎通知");
    }
}
public class PromotionService {
    public void issueNewUserExperienceCash(Long userId){
        System.err.println("新用户体验金来了");
    }
}
/**
 * 注册观察者
 */
public interface RegObserver {
    void handleRegSuccess(Long userId);
}
public class RegNotificationObserver implements RegObserver {
  private NotificationService notificationService=new NotificationService();
  @Override
  public void handleRegSuccess(Long userId) {
    notificationService.sendInboxMessage(userId, "Welcome...");
  }
}
public class RegPromotionObserver implements RegObserver {
    private PromotionService promotionService=new PromotionService() ; // 依赖注入
    @Override
    public void handleRegSuccess(Long userId) {
        promotionService.issueNewUserExperienceCash(userId);
    }
}
public class UserService {
    public Long register(String telephone, String password) {
        return 101L;
    }
}
public class UserController {
    private UserService userService=new UserService();
    private static List<RegObserver> regObservers = new ArrayList<>();
     //多种形式: set/static/反射
    static {
        regObservers.add(new RegNotificationObserver());
        regObservers.add(new RegPromotionObserver());
    }
      public void setRegObservers(List<RegObserver> observers){
          regObservers.addAll(observers);
    }
    public  Long register(String telephone,String password){
        //参数校验
       Long userId= userService.register(telephone,password);
       //可开启线程
        for (RegObserver regObserver: regObservers ) {
            regObserver.handleRegSuccess(userId);
        }
        return userId;
    }
    public static void main(String[] args) {
        UserController userController = new UserController();
//        List<RegObserver> list = new ArrayList<>();
//        list.add(new RegNotificationObserver());
//        list.add(new RegPromotionObserver());
//        userController.setRegObservers(list);
        Long register =userController.register("123", "123");
        System.err.println(register);
    }
}
//反射工具类
public class ClassUtil {
    private static Logger logger=Logger.getLogger(ClassUtil.class.getName());

    /**
     * 获取所有接口的实现类
     * 如果是A.isAssignableFrom(B) 确定一个类(B)是不是继承来自于另一个父类(A),一个接口(A)是不是实现了另外一个接口(B),或者两个类相同。
     * 主要,这里比较的维度不是实例对象,而是类本身,因为这个方法本身就是Class类的方法,判断的肯定是和类信息相关的。
     * 也就是判断当前的Class对象所表示的类,
     * 是不是参数中传递的Class对象所表示的类的父类,超接口,或者是相同的类型。是则返回true,否则返回false。
     * @return
     */
    public static List<Class> getImplByInterface(Class c){
        List<Class> classes = new ArrayList<>();
        //判断是否为接口
        if(!c.isInterface()){
            logger.warning("当前类不是接口");
            return null;
        }else{
            //获得当前包名
            String packageName = c.getPackage().getName();
            try {
                //获得当前包下所有类
                List<Class>  allClass=getAllClassByCurrentPackage(packageName);
                //遍历判断
                for (Class ck:allClass) {
                    String className = ck.getName().substring(ck.getName().lastIndexOf(".") + 1);
                    //排除抽象类
                    if(Modifier.isAbstract(ck.getModifiers())){
                        logger.info("当前类:"+className+"为抽象类");
                        continue;
                    }
                    //判断是否为当前接口的子类或者本接口
                    if(!c.isAssignableFrom(ck)){//不是
                        logger.info("当前类:"+className+"不是当前接口的实现类");
                        continue;
                    }else {
                     //排除自己
                        if(c.equals(ck)){
                            logger.info("当前类"+className+"不可保留,必须排除");
                            continue;
                        }else {
                            classes.add(ck);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return classes;
    }
    /**
     * 获得当前包下所有类,在jar包中不能查找
     * @param packageName
     * @return
     */
    private static List<Class> getAllClassByCurrentPackage(String packageName) throws IOException, ClassNotFoundException {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        String path=packageName.replace(".","/");
        Enumeration<URL> resources = loader.getResources(path);
        List<File> dirs = new ArrayList<>();
        while (resources.hasMoreElements()){
            URL url = resources.nextElement();
            dirs.add(new File(url.getFile()));
        }
        List<Class> classes = new ArrayList<>();
        for (File dir :dirs) {
            classes.addAll(findClasses(dir,packageName));

        }
        return classes;
    }
    private static List<Class> findClasses(File dir, String packageName) throws ClassNotFoundException {
        List<Class> classes = new ArrayList<>();
        if (!dir.exists()) {//文件不存在
            return classes;
        }
//     listFiles   存放的是此文件夹下的文件路径+文件名(包含父级目录的完整路径)
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {//文件是目录,递归遍历
                //递归查找文件夹【即对应的包】下面的所有文件
                assert !file.getName().contains(".");
                /**
                 * J2SE 1.4在语言上提供了一个新特性,就是assertion(断言)功能,它是该版本在Java语言方面最大的革新。在软件开发中,assertion是一种经典的调试、测试方式。
                 在语法上,为了支持assertion,Java增加了一个关键字assert。它包括两种表达式,分别如下:
                   assert expression1; 当为true时,程序正常执行,false时抛出异常终止程序。
                 assert expression1: expression2; 如果表达式1为true时,程序正常运行,如过为false则抛出异常,终止程序,并将表达式2的内容随异常信息一起打印。
                   在两种表达式中,expression1表示一个boolean表达式,
                 expression2表示一个基本类型或者是一个对象(Object) ,基本类型包括boolean,char,double,float,int和long。
                 由于所有类都为Object的子类,因此这个参数可以用于所有对象。
                   assert如果为true,则程序继续执行。如果为false,则程序抛出AssertionError,并终止执行。
                 */
//                递归
                classes.addAll(findClasses(file, packageName + '.' + file.getName()));
            } else if (file.getName().endsWith(".class")) {
                classes.add(Class.forName(packageName + "." + file.getName().substring(0,file.getName().length() - 6)));
            }
        }
        return classes;
    }
}
import top.jkxljc.strategy.demo2.StringUtils;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * @Description: 反射工具类
 * @Auther: wuzhazha
 */
public class ReflectionUtil {
 
    /**
     * 定义类集合(用于存放所有加载的类)
     */
    private static  Set<Class<?>> CLASS_SET;
 
//    static {
//        //指定加载包路径
//        CLASS_SET = getClassSet("com.yaolong");
//    }
//
    /**
     * 获取类加载器
     * @return
     */
    public static ClassLoader getClassLoader(){
        return Thread.currentThread().getContextClassLoader();
    }
    /**
     * 加载类
     * @param className 类全限定名称
     * @param isInitialized 是否在加载完成后执行静态代码块
     * @return
     */
    public static Class<?> loadClass(String className,boolean isInitialized) {
        Class<?> cls;
        try {
            cls = Class.forName(className,isInitialized,getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return cls;
    }
 
    public static Class<?> loadClass(String className) {
        return loadClass(className,true);
    }
    /**
     * 获取指定包下所有类
     * @param packageName
     * @return
     */
    public static Set<Class<?>> getClassSet(String packageName) {
        Set<Class<?>> classSet = new HashSet<>();
        try {
            Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".","/"));
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                if (url != null) {
                    String protocol = url.getProtocol();
                    if (protocol.equals("file")) {
                        String packagePath = url.getPath().replace("%20","");
                        addClass(classSet,packagePath,packageName);
                    } else if (protocol.equals("jar")) {
                        JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
                        if (jarURLConnection != null) {
                            JarFile jarFile = jarURLConnection.getJarFile();
                            if (jarFile != null) {
                                Enumeration<JarEntry> jarEntries = jarFile.entries();
                                while (jarEntries.hasMoreElements()) {
                                    JarEntry jarEntry = jarEntries.nextElement();
                                    String jarEntryName = jarEntry.getName();
                                    if (jarEntryName.endsWith(".class")) {
                                        String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/", ".");
                                        doAddClass(classSet,className);
                                    }
                                }
                            }
                        }
                    }
                }
            }
 
 
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return classSet;
    }
    private static void doAddClass(Set<Class<?>> classSet, String className) {
        Class<?> cls = loadClass(className,false);
        classSet.add(cls);
    }
 
    private static void addClass(Set<Class<?>> classSet, String packagePath, String packageName) {
        final File[] files = new File(packagePath).listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory();
            }
        });
        for (File file : files) {
            String fileName = file.getName();
            if (file.isFile()) {
                String className = fileName.substring(0, fileName.lastIndexOf("."));
                if (StringUtils.isNotEmpty(packageName)) {
                    className = packageName + "." + className;
                }
                doAddClass(classSet,className);
            } else {
                String subPackagePath = fileName;
                if (StringUtils.isNotEmpty(packagePath)) {
                    subPackagePath = packagePath + "/" + subPackagePath;
                }
                String subPackageName = fileName;
                if (StringUtils.isNotEmpty(packageName)) {
                    subPackageName = packageName + "." + subPackageName;
                }
                addClass(classSet,subPackagePath,subPackageName);
            }
        }
    }
    public static Set<Class<?>> getClassSet() {
        CLASS_SET= getClassSet(ReflectionUtil.class.getPackage().getName());
        return CLASS_SET;
    }
    /**
     * 获取应用包名下某父类(或接口)的所有子类(或实现类)
     * @param superClass
     * @return
     */
    public static Set<Class<?>> getClassSetBySuper(Class<?> superClass) {
        return getClassSetBySuper(superClass, ReflectionUtil.class.getPackage().getName());
    }
    public static Set<Class<?>> getClassSetBySuper(Class<?> superClass,String packageName) {
        CLASS_SET= getClassSet(packageName);
        Set<Class<?>> classSet = new HashSet<>();
        for (Class<?> cls : CLASS_SET) {
            if (superClass.isAssignableFrom(cls) && !superClass.equals(cls)) {
                classSet.add(cls);
            }
        }
        return classSet;
    }
    /**
     * 获取应用包名下带有某注解的类
     * @param annotationClass
     * @return
     */
    public static Set<Class<?>> getClassSetByAnnotation(Class<? extends Annotation> annotationClass) {
        CLASS_SET= getClassSet(ReflectionUtil.class.getPackage().getName());
        Set<Class<?>> classSet = new HashSet<>();
        for (Class<?> cls : CLASS_SET) {
            //是否存在此注解
            if (cls.isAnnotationPresent(annotationClass)) {
                classSet.add(cls);
            }
        }
        return classSet;
    }
}
  • 此时需要添加新的观察者,只需要增加一个类实现观察者接口就行,不用修改别的代码(用户注册成功之后,推送用户注册信息给大数据征信系统)
  • 优化代码(同步阻塞变为异步非阻塞):当 userService.register() 函数执行完成之后,我们启动一个新的线程来执行观察者的 handleRegSuccess() 函数,这样 userController.register() 函数就不需要等到所有的 handleRegSuccess() 函数都执行完成之后才返回结果给客户端--------userController.register() 函数从执行 3 个 SQL 语句才返回,减少到只需要执行 1 个 SQL 语句就返回,响应时间粗略来讲减少为原来的 1/3。本质在进程内
  • 再优化跨进程:
    • 大数据征信系统提供了发送用户注册信息的 RPC 接口,我们仍然可以沿用之前的实现思路,在 handleRegSuccess() 函数中调用 RPC 接口来发送数据。
    • 基于消息队列(Message Queue,比如 ActiveMQ)来实现。
      • 优势:
        1. 被观察者和观察者解耦更加彻底,两部分的耦合更小
        2. 被观察者完全不感知观察者,同理,观察者也完全不感知被观察者。
        3. 被观察者只管发送消息到消息队列,观察者只管从消息队列中读取消息来执行相应的逻辑。

3、优缺点:

创建型:将创建和使用代码解耦
结构型:将不同功能代码解耦,
行为型:不同的行为代码解耦,具体到观察者模式,它是将观察者和被观察者代码解耦

优点:

  1. 观察者和观察者抽象耦合(观察者和被观察者代码解耦)
  2. 建立一套触发机制

缺点:

  • 1、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。
  • 2、如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
  • 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

4、应用场景:

小到代码层面的解耦,大到架构层面的系统解耦,再或者一些产品的设计思路。

  1. 邮件订阅
  2. RSS fEEDS
  3. 微信公众号
  4. 支付场景:
    • 用户购买一件商品,当支付成功之后三方会回调自身,在这个时候系统可能会有很多需要执行的逻辑(如:更新订单状态,发送邮件通知,赠送礼品…),这些逻辑之间并没有强耦合,因此天然适合使用观察者模式去实现这些功能,当有更多的操作时,只需要添加新的观察者就能实现,完美实现了对修改关闭,对扩展开放的开闭原则。
  5. UGC(用户原创内容)场景
    • 在一个UGC场景下,用户发布的内容往往会经过很多流程,大部分是先发往审核系统,当审核通过之后就会出现一系列的业务逻辑,比如更新内容状态,通知给所有的粉丝等等,而这些业务逻辑就可以作为观察者。
物理专业书库模板(1):物理学书单(适合物理专业本科生、研究生、科研工作者、物理爱好者...) 物理专业书库模板(1):物理学书单(适合物理专业本科生、研究生、科研工作者、物理爱好者...) 求赞求喜欢求分享,建议关注,防止文章丢失。 阅读详情

相关推荐

SRv6项目实践(三):P4Runtime基础以及交换机控制

在正式介绍P4runtime基础之前,先说一说P4的编译和实现的过程该文件包含了各个表和操作,它们的id用一个索引值来表示,比如a表用b操作,不会直接说用名字为B的操作,而是说用索引为xxx的操作,然后锁定到b上执行相关的功能,其次,用了一个bitwith来描述,要访问的数据的比特长度是多长。p4c编译器将p4编译成两份文件,其中一份是,另一份是,将这两个文件再整合起来,作为配置,放到交换机中。

a1164520408的博客 3411

设计模式之观察者模式(ObserverPattern)

设计模式之观察者模式(ObserverPattern) 文章目录设计模式之观察者模式(ObserverPattern)一.观察者模式(ObserverPattern)二.编程实例1.进制转换器2.客人敲门案例 一.观察者模式(ObserverPattern) 在生活中会遇到很多使用观察者模式的案例,比如股票跌涨后,股民作为观察者会对股票进行交易;客人来敲门,门铃响了之后管家就会去开门等等。其中观...

Worthy_Wang的博客 622

八路抢答器____一个作品的制作思路

学习了解到一个产品制作完全由一个人去采购,设计,仿真,画PCB。不光是需求的分析还有实现功能时如何搭建电路,和给出一个简单高效的设计方法也是至关重要的。

weixin_73690807的博客 1527

设计模式之观察者模式ObserverPattern(十一)

观察者模式 (Observer Pattern) 是一种行为型设计模式,又被称为发布-订阅 (Publish/Subscribe) 模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会自动收到通知并更新。

徐泗空的博客 1048

Halcon实战:基于图像清晰度自动筛选最佳对焦图片

本文详细介绍了如何使用Halcon实现基于图像清晰度的自动筛选最佳对焦图片技术。通过分析灰度值统计和标准差等核心指标,结合实战代码示例,帮助开发者高效处理工业检测中的对焦问题,提升自动化检测的准确性和效率。

weixin_27015733的博客 444

ubuntu 安装node和npm

在ubuntu中经常需要用到node ,npm,因为npm基本会和node同时安装,所以只需要安装node即可。可以使用 nvm(Node Version Manager)来管理你的 Node.js 版本。

风吹落叶的博客 2293

设计模式之ObserverPattern观察者模式

现实世界中,许多对象并不是独立存在的,其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如,某种商品的物价上涨时会导致部分商家高兴,而消费者伤心;还有,当我们开车到交叉路口时,遇到红灯会停,遇到绿灯会行。 在软件世界也是这样,例如,Excel 中的数据与折线图、饼状图、柱状图之间的关系;MVC 模式中的模型与视图的关系。所有这些,如果用观察者模式来实现就非常方便。 观察者Observer模式的特点和定义: 观察者(Observer)模式的定义:指多个对象间存在一对多的依赖关系,当一

haoyuegongzi的博客 326

论文阅读:Training language models to follow instructions with human feedback

这篇论文的目标是通过引入一种基于人类反馈的训练方法,来让语言模型更好地按照用户意图行事。这是因为大规模语言模型虽然强大,但有时候会生成不准确、有偏见或者对用户无帮助的内容,这说明它们和用户的需求之间存在一定的“错位”。论文提出了一个新方法,将 GPT-3 进行优化,称为示例数据与监督学习:让人类标注员生成一些正确行为的示例,并使用这些示例来初步优化模型。比较数据与奖励模型:让标注员比较模型生成的多个输出,并将其排序,从中学到模型输出的优劣规则。强化学习优化:基于这些规则,使用强化学习算法进一步优化模型。

CSPhD-winston的博客 1719

【24种设计模式】观察者模式(Observer Pattern)

这种模式实现了一种一对多的对象依赖关系,当一个对象的状态改变时,所有依赖它的对象都会得到通知并自动更新。总结起来,观察者模式通过定义主题和观察者之间的接口,实现了一种松耦合的对象间通信方式。观察者模式中,通知观察者的算法骨架是固定的,但具体的通知操作可以由不同的观察者进行实现。在状态模式中,状态的改变会导致行为的改变,而在观察者模式中,状态的改变会导致通知给观察者。发布-订阅模式:发布-订阅模式是观察者模式的一种扩展,它将观察者分组,通过消息队列、事件总线等机制实现观察者与主题之间的松耦合通信。

Bankcary的博客 632

把业务变化变成实时流动:SAP Event Mesh 的概念、能力与落地方法

SAP Event Mesh 是 SAP BTP 上的云消息与事件服务,通过异步事件通信实现系统解耦。核心功能包括:1)提供Topic(广播)和Queue(持久化)两种消息模式;2)支持AMQP、MQTT、REST等多种协议接入;3)作为SAP生态的事件枢纽,可与SAP Integration Suite、CAP框架等无缝集成。典型应用场景:S/4HANA业务事件驱动流程、微服务扩展、IoT设备数据上云等。相比同步调用,它能显著提升系统弹性,避免雪崩故障,特别适合需要实时性与松耦合的企业级集成。高级版本(A

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 252

2026年海能达嵌入式岗位面试题集(含参考答案)

本文总结了嵌入式系统开发中的常见面试题,涵盖项目经验、外设接口、存储系统、编程基础、操作系统等核心模块。主要内容包括:1)项目核心经历的硬件/软件架构及问题解决思路;2)SPI、I2C等接口协议的时序特点与应用要点;3)NAND Flash存储管理中的ECC校验原理和文件系统对接方案;4)USB设备枚举流程等关键知识点。这些题目针对嵌入式岗位的技术考察重点,既包含底层硬件接口细节,也涉及系统级设计与优化策略,全面考察开发者的嵌入式系统能力。

Open 364

设计模式-观察者模式-Observer Pattern

观察者模式的优点包括实现了观察者和被观察者之间的解耦,增加了程序的可扩展性,并且可以动态地添加或移除观察者。:观察者模式能够将被观察者(Subject)和观察者(Observer)解耦,使得被观察者的改变不会直接影响到观察者,两者之间的依赖关系降低。:在需要实现通知和消息传递的系统中,观察者模式可以用来通知用户或系统组件关于状态变化的信息,如电子邮件客户端中的新邮件通知。:在观察者模式中,如果一个观察者在更新时发生错误,可能会影响到其他观察者的更新,这需要在设计时考虑错误处理机制。

wesigj的博客 1483

AutoSAR系列讲解(深入篇)14.7-Mcal Adc配置(上)

详细讲解了ADC的各个配置项的作用

雪云飞星的博客 1万+

设计模式——行为型——观察者模式ObserverPattern

https://en.wikipedia.org/wiki/Observer_pattern

bbllbbcpt的专栏 305

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

设计模式-观察者模式(Observer Pattern)

观察者模式 定义 观察者模式,又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象。 类型 行为型。 角色 抽象主题(Subject)角色:也叫抽象目标类,它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法,以及通知所有观察者的抽象方法。 具体主题(Co...

kaven 1451

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

设计模式教程:观察者模式(Observer Pattern)

定义对象之间的一对多依赖关系,当一个对象状态变化时,所有依赖于它的对象都会得到通知并自动更新。

遇见伯灵说的博客 1246

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

c++ 设计模式_设计模式行为型:观察者模式(ObserverPattern)

定义对象之间的一种一对多依赖关系,使得每一个对象发生状态的变化时,其相关依赖对象皆得到通知并被自动更新,又称为发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependence)模式。结构图角色与理解观察者模式共分为四种角色: Subject(目标类):被观察的对象,内部定义一个观察者集合,并...

weixin_39974223的博客 111

设计模式之观察者模式(Observer Pattern)

六大原则:单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特原则。 二十三设计模式:单例模式、Builder 模式、原型模式、工厂方法模式、抽象工厂模式、策略模式、状态模式、责任链模式、解释器模式、命令模式、观察者模式

Mr_Four 310

23种设计模式——观察者模式(Observer Pattern)​详解

本文介绍了23种经典设计模式之——观察者模式(Observer Pattern)​的说明及使用。

Meteors.的博客 1224

设计模式中的观察者模式(Observer Pattern)

在软件开发中,经常遇到对象之间存在依赖关系的情况,例如GUI 组件事件处理、消息订阅系统、股票价格更新、数据监听等。如果使用传统的方法(如轮询),不仅浪费资源,还可能导致数据不同步。观察者模式(Observer Pattern)提供了一种一对多的依赖关系,当被观察对象(Subject)状态发生变化时,会自动通知所有观察者(Observer),从而实现低耦合、自动更新的通知机制。本文将详细介绍观察者模式的概念、应用场景,并通过 Python 代码示例展示其实现。

1102

Java 设计模式——观察者模式(Observer Pattern)

    前言 一、简介 二、实现步骤 (1)实现方式: (2)举例: (3)步骤简化版: 三、代码实现 四、总结 五、Demo地址 六、参考文档 七、内容推荐 前言 本来没想写前言的,感觉就是一堆废话。那就当废话浏览一下吧,只是提醒一下自己一些注意的东西。 在许多博客当中看到把观察者模式又称呼为发布-订阅模式。其实我感觉两者确实很相似,但还是有一丢丢的区别: 在...

斌林诚上的博客 727

设计模式之观察者模式(Observer Pattern),C++篇

观察者模式是一种行为设计模式,用于对象间一对多的依赖关系。当被观察对象状态改变时,会自动通知所有依赖的观察者。该模式包含四个核心角色:主题(Subject)、观察者(Observer)、具体主题(Concrete Subject)和具体观察者(Concrete Observer)。适用场景包括事件处理系统、消息传递等需要松耦合通知机制的场合。代码示例展示了C++实现,通过主题维护观察者列表,在状态变化时循环通知所有观察者进行更新。该模式有效降低了对象间的耦合度,适用于状态变化引发连锁反应的系统设计。

guoguojiang_的博客 1004

设计模式---观察者模式(DesignPattern_Observer)

摘录自:设计模式与游戏完美开发 十年磨一剑,作者将设计模式理论巧妙地融入到实践中,以一个游戏的完整实现呈现设计模式的应用及经验的传承 《轩辕剑》之父——蔡明宏、资深游戏制作人——李佳泽、Product Evangelist at Unity Technologies——Kelvin Lo、信仁软件设计创办人—— 赖信仁、资深3D游戏美术——刘明恺 联合推荐全书采用了整合...

su9257的博客 162

设计模式——观察者模式(Observer Pattern)+ Spring相关源码

当一个对象的状态发生改变时,其所有依赖者(观察者)都会收到通知并自动更新

码鹿的记录 1127
上一篇: 设计模式-享元模式(FlyWeight-Pattern)
下一篇: 同步、异步与阻塞的关联
ADCQprogrammer
博客等级 码龄7年 4粉丝 21原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值