02.设计模式之模板方法和观察者模式

已于 2022-06-22 11:53:23 修改
阅读量224 收藏
点赞数
分类专栏： springboot 每特教育第十一期 文章标签： 设计模式 观察者模式 策略模式
于 2022-06-21 20:46:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014001523/article/details/125398203
版权

模板方法

1.什么是模板方法模式
2.模板方法模式应用场景
3.分布式锁代码使用模板方法重构
4.什么是观察者模式？
5.观察者模式应用场景
6.spring事件监听观察者模式原理分析

20点25分准时开始

什么是模板方法

1.定义了一个操作中的算法的骨架，而将部分步骤的实现在子类中完成。

模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

2.模板方法模式是所有模式中最为常见的几个模式之一，是基于继承的代码复用的基本技术，没有关联关系。 因此，在模板方法模式的类结构图中，只有继承关系。

核心设计要点：

AbstractClass : 抽象类，定义并实现一个模板方法。这个模板方法定义了算法的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类去实现

ConcreteClass : 实现实现父类所定义的一个或多个抽象方法。

一般模板方法是结合策略模式一起使用。

因为策略模式，相同的事情，但是有不同的策略实现

img

模版方法应用场景

\1. 聚合支付系统异步回调、QQ联合登录、对接第三方短信接口、分布式锁实现、jdbc模板

\2. Servlet 请求

对接第三方短信接口

对接阿里云 、华为云、腾讯云 相同事情存放在骨架中（抽象类中 交给子类具体发送）

kafka、rocketmq

kafka

amqpTemplate—执行发送投递消息kafka

rabbitmq

amqpTemplate—执行发送投递消息rabbitmq

分布式锁有哪些实现方式

1.zk分布式锁

2.redis分布式锁

3.数据库分布式锁

分布式锁 获取锁、释放锁

class ZkLock{

tryLock(){

​ Long startTime = System.currentTimeMillis();

​ 获取锁-------zk获取锁具体流程

​ Long endTime = System.currentTimeMillis();

​ 获取锁时间endTime-startTime

}

}

class RedisLock{

tryLock(){

​ Long startTime = System.currentTimeMillis();

​ 获取锁-------redis获取锁具体流程

​ Long endTime = System.currentTimeMillis();

​ 获取锁时间endTime-startTime

}

}

模板重构 有共同的骨架，骨架中有些部分细节不一样 使用模板方法设计模式重构。

模式模式优缺点

1.）优点

模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。子类实现算法的某些细节，有助于算法的扩展。通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

2.）缺点

每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象。

3.）适用场景

在某些类的算法中，用了相同的方法，造成代码的重复。控制子类扩展，子类必须遵守算法规则。

模板方法设计模式 配合抽象类实现

发送短信、查询物流快递—

相同的代码存放—抽象类中。

相关代码

共同骨架

package com.mayikt.lock;

import lombok.extern.slf4j.Slf4j;

/**
* @author 余胜军
* @ClassName AbstractDistributedLock
* @qq 644064779
* @addres www.mayikt.com
* 微信:yushengjun644
*/
@Slf4j
public abstract class DistributedLockTemplate {
    
    /**
    * 获取锁方法
    */
    public void lock() {
        Long startTime = System.currentTimeMillis();
        tryLock();
        Long endTime = System.currentTimeMillis();
        log.info("<获取锁时间,>" + (endTime - startTime));
    }
    
    protected abstract void tryLock();
    
    /**
    * 释放锁方法
    */
    public void unLock() {
        Long startTime = System.currentTimeMillis();
        tryUnLock();
        Long endTime = System.currentTimeMillis();
        log.info("<释放锁时间,>" + (endTime - startTime));
    }
    
    protected abstract void tryUnLock();
    
}

具体实现

package com.mayikt.lock.impl;

import com.mayikt.lock.DistributedLockTemplate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author 余胜军
 * @ClassName RedisDistributedLockTemplate
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@Slf4j
@Component
public class ZkDistributedLockTemplate extends DistributedLockTemplate {
    @Override
    protected void tryLock() {
        try {
            Thread.sleep(5);
        } catch (Exception e) {

        }
        log.info("<zk方法实现获取锁!>");
    }

    @Override
    protected void tryUnLock() {
        try {
            Thread.sleep(3);
        } catch (Exception e) {

        }
        log.info("<zk方法实现释放锁!>");
    }
}

package com.mayikt.lock.impl;

import com.mayikt.lock.DistributedLockTemplate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author 余胜军
 * @ClassName RedisDistributedLockTemplate
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@Slf4j
@Component
public class RedisDistributedLockTemplate extends DistributedLockTemplate {
    @Override
    protected void tryLock() {
        try {
            Thread.sleep(10);
        } catch (Exception e) {

        }
        log.info("<redis方法实现获取锁!>");
    }

    @Override
    protected void tryUnLock() {
        try {
            Thread.sleep(15);
        } catch (Exception e) {

        }
        log.info("<redis方法实现释放锁!>");
    }
}

模板工厂

package com.mayikt.lock.factory;

import com.mayikt.lock.DistributedLockTemplate;
import com.mayikt.lock.utils.SpringUtils;

public class TemplateFactory {

    public static DistributedLockTemplate getPayCallbackTemplate(String templateId) {
        DistributedLockTemplate payCallbackTemplate = (DistributedLockTemplate) SpringUtils.getBean(templateId);
        return payCallbackTemplate;
    }
}

访问测试

package com.mayikt.lock.service;

import com.mayikt.lock.DistributedLockTemplate;
import com.mayikt.lock.factory.TemplateFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 余胜军
 * @ClassName LockTestService
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@RestController
@Slf4j
public class LockTestService {
    @RequestMapping("/lockTest")
    public String lockTest(String templateId) {
        DistributedLockTemplate payCallbackTemplate = TemplateFactory.getPayCallbackTemplate(templateId);
        try {
            payCallbackTemplate.lock();
            log.info("<lockTest>");
            payCallbackTemplate.unLock();
            return "ok";
        } catch (Exception e) {
            payCallbackTemplate.unLock();
            return "error";
        }

    }
}

观察者模式

什么是观察者模式

1.在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。

2.其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。

观察者模式应用场景

Zookeeper事件通知节点、消息订阅通知、安卓开发事件注册、分布式配置中心

观察者模式原理类图

1.抽象被观察者角色：也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者角色，一般用一个抽象类和接口来实现。

2.抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

3.具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。

4.具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

观察者模式模式简单实现

抽象观察者

package com.mayikt.observer;

/**
 * @author 余胜军
 * @ClassName ObServer
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
public interface ObServer {
    /**
     * 抽象观察者
     */
    void update(String message);
}

具体观察者

package com.mayikt.observer.impl;

import com.mayikt.observer.ObServer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author 余胜军
 * @ClassName UserObServerImpl
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */

@Slf4j
public class UserObServerImpl implements ObServer {
    private String name;

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

    @Override
    public void update(String message) {
        log.info("<name:{},message:{}>", name, message);
    }
}

抽象主题

package com.mayikt.subject;

import com.mayikt.observer.ObServer;

/**
 * @author 余胜军
 * @ClassName AbstractSubject
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
public interface AbstractSubject {
    /**
     * 添加addObServer
     */
    void addObServer(ObServer obServer);

    /**
     * removeObServer
     */
    void removeObServer(ObServer obServer);

    /**
     * notifyObServerAll
     */
    void notifyObServerAll(String message);

    void setNotifyObServerAll(String message);
}

具体主题

package com.mayikt.subject.impl;

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

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

/**
 * @author 余胜军
 * @ClassName WeChatSubjectImpl
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
public class WeChatSubjectImpl implements AbstractSubject {
    private List<ObServer> obServers = new ArrayList<ObServer>();
    private String message;

    @Override
    public void addObServer(ObServer obServer) {
        obServers.add(obServer);
    }

    @Override
    public void removeObServer(ObServer obServer) {
        obServers.remove(obServer);
    }

    @Override
    public void notifyObServerAll(String message) {
        obServers.forEach(obServer -> {
            obServer.update(message);
        });
    }

    @Override
    public void setNotifyObServerAll(String message) {
        this.message = message;
        notifyObServerAll(message);
    }
}

测试代码

package com.mayikt;

import com.mayikt.observer.impl.UserObServerImpl;
import com.mayikt.subject.AbstractSubject;
import com.mayikt.subject.impl.WeChatSubjectImpl;

/**
 * @author 余胜军
 * @ClassName Test01
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
public class Test01 {
    public static void main(String[] args) {
        // 1.注册主题
        AbstractSubject abstractSubject = new WeChatSubjectImpl();
        abstractSubject.addObServer(new UserObServerImpl("小敏"));
        abstractSubject.addObServer(new UserObServerImpl("小薇"));
        abstractSubject.setNotifyObServerAll("mayikt666");
    }
}
D:\path\jdk\jdk8\jdk\bin\java.exe -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:59115,suspend=y,server=n -javaagent:C:\Users\mayikt\AppData\Local\JetBrains\IntelliJIdea2020.2\captureAgent\debugger-agent.jar -Dfile.encoding=UTF-8 -classpath "D:\path\jdk\jdk8\jdk\jre\lib\charsets.jar;D:\path\jdk\jdk8\jdk\jre\lib\deploy.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\access-bridge-64.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\cldrdata.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\dnsns.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\jaccess.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\jfxrt.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\localedata.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\nashorn.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\sunec.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\sunjce_provider.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\sunmscapi.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\sunpkcs11.jar;D:\path\jdk\jdk8\jdk\jre\lib\ext\zipfs.jar;D:\path\jdk\jdk8\jdk\jre\lib\javaws.jar;D:\path\jdk\jdk8\jdk\jre\lib\jce.jar;D:\path\jdk\jdk8\jdk\jre\lib\jfr.jar;D:\path\jdk\jdk8\jdk\jre\lib\jfxswt.jar;D:\path\jdk\jdk8\jdk\jre\lib\jsse.jar;D:\path\jdk\jdk8\jdk\jre\lib\management-agent.jar;D:\path\jdk\jdk8\jdk\jre\lib\plugin.jar;D:\path\jdk\jdk8\jdk\jre\lib\resources.jar;D:\path\jdk\jdk8\jdk\jre\lib\rt.jar;D:\data\mayikt-designmode\mayikt-observer\target\classes;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-web\2.2.3.RELEASE\spring-boot-starter-web-2.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter\2.2.3.RELEASE\spring-boot-starter-2.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot\2.2.3.RELEASE\spring-boot-2.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-autoconfigure\2.2.3.RELEASE\spring-boot-autoconfigure-2.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-logging\2.2.3.RELEASE\spring-boot-starter-logging-2.2.3.RELEASE.jar;D:\maven\mvnRespo\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;D:\maven\mvnRespo\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;D:\maven\mvnRespo\org\slf4j\slf4j-api\1.7.30\slf4j-api-1.7.30.jar;D:\maven\mvnRespo\org\apache\logging\log4j\log4j-to-slf4j\2.12.1\log4j-to-slf4j-2.12.1.jar;D:\maven\mvnRespo\org\apache\logging\log4j\log4j-api\2.12.1\log4j-api-2.12.1.jar;D:\maven\mvnRespo\org\slf4j\jul-to-slf4j\1.7.30\jul-to-slf4j-1.7.30.jar;D:\maven\mvnRespo\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;D:\maven\mvnRespo\org\springframework\spring-core\5.2.3.RELEASE\spring-core-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-jcl\5.2.3.RELEASE\spring-jcl-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\yaml\snakeyaml\1.25\snakeyaml-1.25.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-json\2.2.3.RELEASE\spring-boot-starter-json-2.2.3.RELEASE.jar;D:\maven\mvnRespo\com\fasterxml\jackson\core\jackson-databind\2.10.2\jackson-databind-2.10.2.jar;D:\maven\mvnRespo\com\fasterxml\jackson\core\jackson-annotations\2.10.2\jackson-annotations-2.10.2.jar;D:\maven\mvnRespo\com\fasterxml\jackson\core\jackson-core\2.10.2\jackson-core-2.10.2.jar;D:\maven\mvnRespo\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.10.2\jackson-datatype-jdk8-2.10.2.jar;D:\maven\mvnRespo\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.10.2\jackson-datatype-jsr310-2.10.2.jar;D:\maven\mvnRespo\com\fasterxml\jackson\module\jackson-module-parameter-names\2.10.2\jackson-module-parameter-names-2.10.2.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-tomcat\2.2.3.RELEASE\spring-boot-starter-tomcat-2.2.3.RELEASE.jar;D:\maven\mvnRespo\org\apache\tomcat\embed\tomcat-embed-core\9.0.30\tomcat-embed-core-9.0.30.jar;D:\maven\mvnRespo\org\apache\tomcat\embed\tomcat-embed-el\9.0.30\tomcat-embed-el-9.0.30.jar;D:\maven\mvnRespo\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.30\tomcat-embed-websocket-9.0.30.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-validation\2.2.3.RELEASE\spring-boot-starter-validation-2.2.3.RELEASE.jar;D:\maven\mvnRespo\jakarta\validation\jakarta.validation-api\2.0.2\jakarta.validation-api-2.0.2.jar;D:\maven\mvnRespo\org\hibernate\validator\hibernate-validator\6.0.18.Final\hibernate-validator-6.0.18.Final.jar;D:\maven\mvnRespo\org\jboss\logging\jboss-logging\3.4.1.Final\jboss-logging-3.4.1.Final.jar;D:\maven\mvnRespo\com\fasterxml\classmate\1.5.1\classmate-1.5.1.jar;D:\maven\mvnRespo\org\springframework\spring-web\5.2.3.RELEASE\spring-web-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-beans\5.2.3.RELEASE\spring-beans-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-webmvc\5.2.3.RELEASE\spring-webmvc-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-aop\5.2.3.RELEASE\spring-aop-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-context\5.2.3.RELEASE\spring-context-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-expression\5.2.3.RELEASE\spring-expression-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\projectlombok\lombok\1.18.10\lombok-1.18.10.jar;D:\maven\mvnRespo\com\alibaba\fastjson\1.2.73\fastjson-1.2.73.jar;D:\maven\mvnRespo\org\mybatis\spring\boot\mybatis-spring-boot-starter\1.1.1\mybatis-spring-boot-starter-1.1.1.jar;D:\maven\mvnRespo\org\mybatis\spring\boot\mybatis-spring-boot-autoconfigure\1.1.1\mybatis-spring-boot-autoconfigure-1.1.1.jar;D:\maven\mvnRespo\org\mybatis\mybatis\3.4.0\mybatis-3.4.0.jar;D:\maven\mvnRespo\org\mybatis\mybatis-spring\1.3.0\mybatis-spring-1.3.0.jar;D:\maven\mvnRespo\org\springframework\boot\spring-boot-starter-jdbc\2.2.3.RELEASE\spring-boot-starter-jdbc-2.2.3.RELEASE.jar;D:\maven\mvnRespo\com\zaxxer\HikariCP\3.4.2\HikariCP-3.4.2.jar;D:\maven\mvnRespo\org\springframework\spring-jdbc\5.2.3.RELEASE\spring-jdbc-5.2.3.RELEASE.jar;D:\maven\mvnRespo\org\springframework\spring-tx\5.2.3.RELEASE\spring-tx-5.2.3.RELEASE.jar;D:\maven\mvnRespo\mysql\mysql-connector-java\8.0.19\mysql-connector-java-8.0.19.jar;D:\idea-mayikt\IntelliJ IDEA 2020.2.3\lib\idea_rt.jar" com.mayikt.Test01
Connected to the target VM, address: '127.0.0.1:59115', transport: 'socket'
19:49:57.638 [main] INFO com.mayikt.observer.impl.UserObServerImpl - <name:小敏,message:mayikt666>
19:49:57.905 [main] INFO com.mayikt.observer.impl.UserObServerImpl - <name:小薇,message:mayikt666>
Disconnected from the target VM, address: '127.0.0.1:59115', transport: 'socket'

Process finished with exit code 0

JDK自带观察实现消息发送

（1）. Observable类追踪所有的观察者，并通知他们。

（2）. Observer这个接口看起来很熟悉，它和我们之前写的类几乎一样。

package com.mayikt.jdk;

import java.util.Observable;

public class MessageObServable extends Observable {

    @Override
    public void notifyObservers(Object arg) {
        // 1.改变数据
        setChanged();
        // 2.通知所有的观察者改变
        super.notifyObservers(arg);
    }
}

package com.mayikt.jdk;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class EmailObServer implements Observer {
    public void update(Observable o, Object arg) {
        // 1.获取主题
        MessageObServable messageObServable = (MessageObServable) o;
        log.info("发送邮件内容:" + arg);
    }
}

package com.mayikt.jdk;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class SmsObServer implements Observer {
    public void update(Observable o, Object arg) {
        log.info("发送短信内容:" + arg);
    }
}


package com.mayikt.jdk;

import com.alibaba.fastjson.JSONObject;

public class JdkObServer {
    public static void main(String[] args) {
        //1.创建主题
        MessageObServable messageObServable = new MessageObServable();
        // 2.添加订阅者
        messageObServable.addObserver(new EmailObServer());
        messageObServable.addObserver(new SmsObServer());
        // 3.组装消息内容
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("email", "644064779@qq.com");
        jsonObject.put("phone", "15123456789");
        jsonObject.put("text", "恭喜您以1399.00元购买蚂蚁课堂永久会员.");
        messageObServable.notifyObservers(jsonObject.toJSONString());
    }
}

Spring封装事件监听

Spring实现事件通知，底层才观察者模式封装的

package com.mayikt.listener;

import org.springframework.context.ApplicationEvent;

/**
 * @author 余胜军
 * @ClassName OrderCreateEvent
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
public class OrderCreateEvent extends ApplicationEvent {
    private String json;

    public OrderCreateEvent(Object source, String json) {
        super(source);
        this.json = json;
    }

    public String getJson() {
        return json;
    }

    public void setJson(String json) {
        this.json = json;
    }
}

package com.mayikt.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * @author 余胜军
 * @ClassName EmailListener
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@Component
@Slf4j
public class EmailListener implements ApplicationListener<OrderCreateEvent> {
    @Override
    public void onApplicationEvent(OrderCreateEvent event) {
        log.info("<发送邮件,{}>", event.getJson());
    }
}

package com.mayikt.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * @author 余胜军
 * @ClassName EmailListener
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@Component
@Slf4j
public class SmsListener implements ApplicationListener<OrderCreateEvent> {
    @Override
    public void onApplicationEvent(OrderCreateEvent event) {
        log.info("<发送短信,{}>", event.getJson());
    }
}

package com.mayikt.service;

import com.alibaba.fastjson.JSONObject;
import com.mayikt.listener.OrderCreateEvent;
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 余胜军
 * @ClassName OrderService
 * @qq 644064779
 * @addres www.mayikt.com
 * 微信:yushengjun644
 */
@RestController
@Slf4j
public class OrderService {
    @Autowired
    private ApplicationContext applicationContext;

    @RequestMapping("/addOrder")
    public String addOrder() {
        log.info("<创建订单>");
        // 3.组装消息内容
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("email", "644064779@qq.com");
        jsonObject.put("phone", "15123456789");
        jsonObject.put("text", "恭喜您以1399.00元购买蚂蚁课堂永久会员.");
        OrderCreateEvent orderCreateEvent = new OrderCreateEvent(this, jsonObject.toJSONString());
        applicationContext.publishEvent(orderCreateEvent);
        return "success";
    }
}
陌陌龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
模板模式与观察者模式
越自律越自由
09-23 276
我们常把 23 种经典的设计模式分为三类：创建型、结构型、行为型。 分别用来解决什么类型的问题？ 创建型设计模式：对象的创建 结构型设计模式：类或对象的组合或组装 行为型设计模式：类或对象之间的交互 设计模式就是用来解耦的 创建型模式是将创建和使用代码解耦 结构型模式是将不同功能代码解耦 行为型模式是将不同的行为代码解耦 模板模式 模板模式基于继承来实现，回调基于组合来实现 在模板模式经典的实现中，模板方法定义为 final，可以避免被子类重写。需要子类重写的方法定义为 abstract.
模板模式和方法回调及观察者模式的区别
ezconn的博客
09-26 546
模板模式 参考https://blog.csdn.net/ezconn/article/details/108812616 观察者模式 参考https://blog.csdn.net/ezconn/article/details/108564814 方法回调或者说回调函数 回调是一种双向调用关系。A 类事先注册某个函数H到 B 类，A 类在调用 B 类的M函数的时候，B 类反过来调用 A 类注册给它的H函数。这里的 H 函数就是“回调函数”。A 调用 B，B 反过来又调用 A，这种调用机制就叫作“
使用Java8改造出来的模板方法真的是yyds
HollisChuang's Blog
08-23 1962
GitHub 21.3k Star 的Java工程师成神之路，不来了解一下吗！ GitHub 21.3k Star 的Java工程师成神之路，真的不来了解一下吗！ 我们在日常开发中，经常会遇到类似的场景：当要做一件事儿的时候，这件事儿的步骤是固定好的，但是每一个步骤的具体实现方式是不一定的。 通常，遇到这种情况，我们会把所有要做的事儿抽象到一个抽象类中，并在该类中定义一个模板方法。这就是所谓的模板方法模式。 以前的模板方法 在我之前的一篇《设计模式——模板方法设计模式》文章中举过一个例子： 当我们去银行的营
设计模式之模板方法模式
qq_22685435的博客
08-22 134
前言 模板方法设计模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构情况下，重新定义算法中的步骤。 一、模板方法设计模式 我们以冲咖啡和茶为例。当我们不使用模板模式的时候我们会定义如下两个类。 public class Coffee { public final void prepareRecipe(){ boilWater(); brew(); pourInCup(); addCond
模板应用--观察者模式
hebezai的专栏
08-27 2401
c++模板实现的线程安全观察者模式，支持观察多个对象，观察者与Subject之间无耦
Javascript设计模式之观察者模式(推荐)
11-23
观察者模式是软件设计模式的一种，它在JavaScript中被广泛应用于事件驱动编程和实时数据更新。该模式的核心思想是定义对象间的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在...
设计模式之美——教你写出高质量代码
04-10
3. 行为型模式：如策略模式、模板方法模式、观察者模式、命令模式、迭代器模式、责任链模式、备忘录模式、状态模式、解释器模式和访问者模式。这些模式主要处理对象之间的通信和行为，让代码更易于理解和扩展。 在...
java.设计模式大作业 薪资交付系统
03-13
4. **观察者模式**：当薪资数据发生变化时，例如员工工资调整或者税率更新，可以使用观察者模式通知相关的组件进行更新，确保数据的一致性。 5. **装饰器模式**：如果需要在原有薪资计算基础上添加额外的福利或扣除...
java-design-patterns-PPT.zip_观察者模式ppt
09-14
3. **行为型模式**: 包括观察者模式在内的模式，如策略模式、模板方法模式、职责链模式、命令模式、迭代器模式、访问者模式、备忘录模式、解释器模式，它们关注对象间的交互和行为。 **观察者模式的优势** 1. **松...
JAVA之23种设计模式的完整实例代码.rar
06-16
这个"JAVA之23种设计模式的完整实例代码.rar"压缩包文件包含了23个经典的设计模式的Java实现，对于学习和理解设计模式非常有帮助。 1. **单例模式**：确保一个类只有一个实例，并提供一个全局访问点。在Java中，...
设计模式之模板方法模式（Java实现）
qq_46234643的博客
06-23 179
模板方法模式
行为型设计模式之模板模式，观察者模式。定义、应用场景、优缺点
最新发布
dingxiao123的博客
06-26 149
通过类之间不同通信方式实现不同行为。包括责任链/命名/解释器/迭代器/中介者/备忘录/观察者/状态/策略/模板/访问者模式。
23种设计模式之模板方法模式
阿武刚巴得
08-23 3537
一直以来我总是容易将工厂方法模式与模板方法模式混淆,它们两个实在太像了.对于我来说造成这样的错觉,源于我对模板方法模式的不了解,这里重点学习模板方法模式. 一、什么是模板方法模式 模板方法模式在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤. 模版方法模式的结构 模版方法模式由一个抽象类和一个（或一组）实现类通...
设计模式学习笔记（二）工厂模式、模板模式和策略模式的混合使用
weixin_45536242的博客
07-13 929
工厂模式又叫做工厂方法模式，是一种创建型设计模式，一般是在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。工厂模式是Java 中比较常见的一种设计模式，实现方法是定义一个统一创建对象的接口，让其子类自己决定去实例化那个工厂类，解决不同条件下创建不同实例的问题。工厂方法模式在实际使用时会和其他的设计模式一起结合，而不是单独使用。比如在Lottery 项目中奖品的发放就是工厂+模板+策略模式。举个例子，比如要实现不同奖品的发放业务，有优惠券、实体商品和会员电子卡这些奖品，那么我们可以定义这三种类型奖
模板方法模式简介及使用示例
。鲸落
06-13 1207
文章目录模板方法模式简介使用示例总结优缺点扩展联想学习 模板方法模式简介 模板方法模式（Template Method），定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。 使用示例 public abstract class AbstractClass { public void algorithmMeth...
设计模式之模板方法模式（附应用举例实现）
pursuit的博客
05-01 2807
设计模式之模板方法模式（附应用举例实现）
设计模式——模板方法模式（附代码示例）
枫陵的博客
05-23 1180
一. 概念 模板方法模式(Template Method Pattern)，又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。 简单说，模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤。这种类型的设计模式属于行为型模式。 二. 原理类图 Abstra...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陌陌龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值