技能篇:实际开发常用设计模式

老老老JR老北
发布于 2023-11-27 11:17
浏览
0收藏

技能篇:实际开发常用设计模式-鸿蒙开发者社区

创建型

单例模式

单例对象能节约系统资源,一个对象的创建和消亡的开销可能很小。但是日常的服务接口,就算是一般小公司也有十几万的QPS吧。每一次的功能运转都创建新的对象来响应请求,十几万对象的创建和销毁,想想就是一笔大开销,所以 spring 管理构造的 bean 对象一般都是单例。而且单例模式可以更好的解决并发的问题,方便实现数据的同步性

  • 优点

      ○  在内存中只有一个对象,节省内存空间

      ○  避免频繁的创建销毁对象,可以提高性能

      ○  避免对共享资源的多重占用,简化访问

      ○  为整个系统提供一个全局访问点

  • 缺点

      ○  不适用于变化频繁的对象

//饿汉式
private static Singleton singleton = new Singleton();

//懒汉式
private static Singleton singleton;
public static Singleton getSingleton(){
    if (singleton == null) {
        singleton = new Singleton(); //被动创建,在真正需要使用时才去创建
    }
    return singleton;
}

//双重判断加锁机制
private volatile static Singleton instance;
//程序运行时创建一个静态只读的进程辅助对象
public static Singleton GetInstance(){
    //先判断是否存在,不存在再加锁处理
    if (instance == null){
        synchronized (Singleton.class){
            if(instance == null){
                instance = new Singleton();
            }
        }
    }
    return instance;
}

//静态初始化
private static readonly Singleton instance= new Singleton();
public static Singleton GetInstance(){
    return instance;
}

工厂模式

使用者不关心对象的实例化过程,只关心对象的获取。工厂模式使得产品的实例化过程和消费者解耦

  • 优点

      ○  一个调用者想创建一个对象,只需通过其名称或其他唯一键值在工厂获取

      ○  扩展性高,如果想增加生产一种类型对象,只要扩展工厂类就可以

  • 缺点

      ○  工厂类不太理想,因为每增加一产品,都要在工厂类中增加相应的生产判断逻辑,这是违背开闭原则的

public interface Sender{  public void send();  }  
public class MailSender implements Sender {  
    @Override  
    public void send(){  
        System.out.println("this is mailsender!");  
    }  
}
public class SmsSender implements Sender {  
    @Override  
    public void send(){  
        System.out.println("this is sms sender!");  
    }  
}
public class SendFactory {  
    public Sender produce(String type){  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            return null;  
        }  
    } 
    //若还有其他产品 则在工厂里加对应的 produce 方法
}  

建造者模式

主要解决在软件系统中一个复杂对象的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定

  • 优点

      ○  扩展性好,对象每一个属性的构建相互独立,有利于解耦。

      ○  建造者可以对创建过程逐步细化,而不对其它模块产生任何影响,便于控制细节风险

  • 缺点

      ○  如果对象建造者发生变化,则建造者也要同步修改,后期维护成本较大

      ○  一种建造者对应一种类型建造,一个建造者基本很难建造多种类型对象

@Data
class Product {
    private String name;
    private String price;
    // Product 的建造者  Builder
    public static class Builder{
        public static Builder builder(){
            Builder builder = Builder();
        }
        private Product product = new Product();
        public Builder name(String name){ product.name = name; return this;}
        public Builder price(String price){ product.price = price; return this; }
        //返回产品对象
        public Product build(){ return product; }
    }
}

结构型

适配器模式

连通上下游功能。一般是现有的功能和产品要求的接口不兼容,需要做转换适配。平时见到的 PO,BO,VO,DTO 模型对象之间的相互转换也是一种适配的过程

  • 优点:提高了类的复用,灵活性好
  • 缺点:过多地使用适配器,会让系统非常零乱,不易整体进行把握。比如,明明看到调用的是 A 接口,其实内部被适配成了 B 接口的实现

//类的适配器模式
public class Source {  
    public void sayHello(){  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
// Source 用 Adapter 适配成 Targetable
public class Adapter extends Source implements Targetable {  
    @Override  
    public void hi(){  
        System.out.println("csc:hi!");  
    }  
}

//对象的适配器模式
public class Source {  
    public void sayHello(){  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
//  Source的对象适配成 Targetable
public class Adapter implements Targetable {
    private Source source;  
    public Adapter(Source source){ this.source = source; }
    public void sayHello(){ source.sayHello(); }
    @Override  
    public void hi(){  
        System.out.println("csc:hi!");  
    }  
}

装饰器模式

增强对象功能,动态的为一个对象增加功能,而且还能动态撤销。(继承不能做到这一点,继承的功能是静态的,不能动态增删)

public interface Show(){ public void acting(); }
public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}  
public class DecoratorArtist implements Show{
    Artist artist;
    DecoratorArt(Artist artist){
        this.artist = artist;
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //增强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //增强的功能
    }
}

代理模式

代理类是客户类和委托类的中介,可以通过给代理类增加额外的功能来扩展委托类的功能,这样只需要修改代理类而不需要再修改委托类,符合代码设计的开闭原则

  • 和装饰器模式的区别:代理模式着重于增强类功能,且对面屏蔽原对象的创建过程;装饰器模式增强的是对象,且装饰器模式有一个动态传递原对象的步骤
  • 和对象的适配器模式优点像:不过代理模式着重的是对原功能增强,适配器模式着重的是对新功能的兼容
  • 优点-1、职责清晰。2、高扩展性

public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}
public class ProxyArtist implements Show{
    Artist artist;
    ProxyArtist(){ 
        this.artist = new Artist();//屏蔽了 artist 对象的创建
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //增强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //增强的功能
    }
}
public class Demo {
    public static void main(String[] arg){
        Show show = new ProxyArtist();
        show.acting();
    }
}

桥接模式

桥接模式侧重于功能的抽象,从而基于这些抽象接口构建上层功能。一般的java 项目都会将接口和实现分离原因,就是基于桥接模式。提高了系统的扩展能力,当引用的底层逻辑有不同的设计实现时,继承抽象接口重新实现一套即可,旧的不变,符合代码设计的开闭原则

  • jdbc 的驱动:常用的JDBC 和 DriverManager,JDBC进行连接数据库的时候,在各个数据库之间进行切换,基本不需要动太多的代码,原因就是JDBC提供统一接口,每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接
  • Unix 的文件系统:VFS(virtual File System)使得 Unix 系统可以在不同物理介质上的不同文件系统进行读写

public interface FileSystem(){ 
  public void open(int file); 
  public String loading(int file); 
  public void store(int file, String data); 
}
//网络上的文件系统
public class NetFileSystem implements FileSystem {  
  public void open(int file){ System.out.println(" netfile opening...."); }
  public String loading(int file){System.out.println(" net loading ...."); }  
  public void store(int file, String data){System.out.println(" send to network ...."); }  
}
//磁盘文件系统
public class DiskFileSystem implements FileSystem{
  public void open(int file){ System.out.println(" disk opening...."); }
  public String loading(int file){System.out.println(" disk loading ...."); } 
  public void store(int file, String data){System.out.println(" write back disk ...."); }   
}
public class Linux {
    FileSystem fileSystem; 
    //底层功能提供接口,桥接模式:功能和具体实现分离
    //可以桥接 NetFileSystem 或者 DiskFileSystem 作为文件系统
    public void set(FileSystem fileSystem){ this.fileSystem = fileSystem; }
    //上层功能读数据
    public String read(int file){
        fileSystem.open(file);
        ... // Linux 自己的系统功能
        fileSystem.loading(file);
        ... 
    }
    //上层功能写数据
    public String write(int file, String data){
        fileSystem.open(file);
        ....
        fileSystem.store(file,data);
    }
}
  • 可配合适配器模式使用

享元模式

多个对象共享某些属性。在创建有大量对象时,可能会造成内存溢出,把其中共同的部分抽象出来,如果有相同的请求,直接返回在内存中同一份属性,避免重新创建

  • 如 jdbc 连接池的连接对象,它们会共享池对象的 url、driverClassName、username、password 等属性

public class ConnectionPool {  
    private Vector<Connection> pool;  
    /*公有属性*/  
    private String url = "jdbc:mysql://localhost:3306/test";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
    public ConnectionPool(){  
        pool = new Vector<Connection>(poolSize);  
        for (int i = 0; i < poolSize; i++) {  
            Class.forName(driverClassName);  
                // 每一个 conn 共享了 driverClassName ,url, username, password 等属性
                Connection conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);
            }
    }
    ....
}

外观模式

  • 用多个不同的对象实现一组更复杂的功能。使得类与类之间的关系解耦。如 spring 将使用各个简单的 component、dao 实现复杂的service,就是一种外观模式
  • 功能的组合,组合优于继承

public class DAO { 
    public void queryData(){
        System.out.print(" query data ")
    }
}
public class Deal {  
    public void dealData(){
        System.out.print(" dealing data ")
    }
}
public class Sender {  
    public void send(){
        System.out.print(" send data ")
    }
}
public class Service(){
    private DAO dao;  
    private Deal deal;  
    private Sender sender;
    //封装 DAO,Deal,Sender 的功能,统一对外提供服务
    public void reponse(){
        dao.queryData();
        deal.dealData();
        sender.send();
    }
}

行为型

策略模式

策略模式侧重于不同的场景使用不同的策略。在有多种算法相似的情况下,解决 if...else 所带来的复杂和难以维护

  • 和桥接模式的区别:而桥接模式是结构型模式,侧重于分离底层功能的抽象和实现,底层只有一种实现也可以

// 上学的策略
abstract class Strategy{
    private static final Map<Integer,Strategy> strategyMap = new ConcurrentHashMap<>();
    public Strategy(){
        strategyMap.put(getType(), this);
    }
    public static Strategy routing(int type){
        return strategyMap.get(type);
    }
    abstract int getType();
    abstract void method(); //留待子类实现差异
}
//跑路去学校
class RunningStrategy extends Strategy{
    int getType(){ return 0; }
    void method(){ System.out.println(" Run to school "); }
}
//公交去学校
class BusStrategy extends Strategy{
    int getType(){ return 1; }
    void method(){ System.out.println(" Go to school by bus "); }
}
//飞去学校
class FlyStrategy extends Strategy{
    int getType(){ return 2; }
    void method(){ System.out.println(" Fly to school "); }
}
class Context{
    //使用不同的策略
    void method(int strategy){
        Strategy.routing(strategy).method();
    }
}

模板方法

和享元模式有一定的相似处,享元模式侧重于属性的共享,而且是结构上的引用,不一定需要继承;而模板方法是共享相同行为,一定有继承行为

  • 区别于策略模式是它有能抽象出来的共同行为,每一个子类再实现有差异细节

abstract class AbstractHandler{
    // handle是抽象出来的共同逻辑
    void handle(String data){
        System.out.println("通用逻辑1...");
        stepOne(data);
        System.out.println("通用逻辑2...");
        stepTwo(data);
        System.out.println("通用逻辑3...");
    }
    abstract void stepOne(String data); //留待子类实现差异
    abstract void stepTwo(String data); //留待子类实现差异
}
class HelloHandler extends AbstractHandler{
    @Override
    void stepOne(String data){
        System.out.println("hello: "+data);
    }
    @Override
    void stepTwo(String data){
        System.out.println("hi: "+data);
    }
}

迭代子模式

循环处理多个相同对象,用来遍历集合或者数组

//迭代的抽象接口
public interface Iterator {  
    //前移  
    public Object previous();  
    //后移  
    public Object next();  
    public boolean hasNext();   
} 
// 数组的迭代类
public class ArrayIterator implements Iterator {  
    private Object[] datas; 
    private int cur = 0;  
    public ArrayIterator(Object[] datas){  
        this.datas = datas;  
    }  
    public String previous(){  
        if(cur > 0){ cur--;}  
        return datas[cur];  
    }  
    public Object next(){  
        if(cur < datas.length-1){ cur++;}  
        return datas[cur];  
    }  
    public boolean hasNext(){  
        return pos < datas.length-1 ? true :false;
    }  
}  

责任链模式

负责处理上游的传递下来的对象,并传递给下一个处理者

  • 和迭代子模式的区别,责任链模式是多个hander处理同一个data,且 hander 处理具有顺序性,不用全部 hander 处理,可在某一 hander 中断,也可继续传递

abstract class Handler<T,R> {
    private Handler<R,?> next;
    abstract R handle(T data);
    public void setNext(Handler<R, ?> next){ this.next = next; }
    public void loopHandle(T data){
        R result = this.handle(data);
        if(next!=null && result!=null ) { next.loopHandle(result); }
    }
}
//负责问候
class HelloHandler extends Handler<String, Integer> {
    Integer handle(String data){
        System.out.println(data + " hello! ");
        return 10;
    }
}
//负责计数
class CountHandler extends Handler<Integer, Double> {
    Double handle(Integer data){
        System.out.println(" it is " + data);
        return 2.0;
    }
}
public class demo{
    public static void main(String[] args){
        HelloHandler hello = new HelloHandler();
        CountHandler count = new CountHandler();
        hello.setNext(count);
        hello.loopHandle("lwl");
    }
}

观察者模式

事件通知: 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知

  • 优点:观察者和被观察者是抽象耦合的
  • 缺点

      ○  如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间

      ○  如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃

//观察者
public abstract class Observer<T> {
    public abstract void update(T data);
}
// 被观察对象
public class Subject<T> {
    private List<Observer<T>> observers = new ArrayList<>();
    private T state;
    public void deal(){ 
        ....// 逻辑处理
        //如果修改了 state,通知观察者
        if(...) notifyAllObservers();
    }
    //增加一个观察观察
    public void observe(Observer<T> observer){
        observers.add(observer);
    }
    public void notifyAllObservers(){
        for (Observer<T> observer : observers) {
            observer.update(state);
        }
    }
}

状态机模式

不同的状态不同的响应,实现状态之间的转移

  • 和策略模式的区别

      ○  状态机模式是策略模式的孪生兄弟。策略模式可以让用户指定更换的策略算法,而状态机模式是状态在满足一定条件下的自动更换,用户无法指定状态,最多只能设置初始状态

      ○  状态机模式重点在各状态之间的切换,从而做不同的事情;而策略模式更侧重于根据具体情况选择策略,并不涉及切换

interface State<T> {
    //当前状态进行处理数据,并返回下一个状态
    abstract State<T> action(T data);
}
@Data
class Context<T>{
    private State<T> state;
    public void invoke(T data){
        state != null ? state = state.action(data) : System.out.println(" nothing " + data);
    }
}
// HelloState -> HiState
class HelloState implements State<String>{
    public State<String> action(String data){
        System.out.println("hello!" + data);
        return new HiState();
    }
}
// HiState -> FineState
class HiState implements State<String>{
    public State<String> action(String data){
        System.out.println("how are you ?" + data);
        return new FineState();
    }
}
//最后的状态
class FineState implements State<String>{
    public State<String> action(String data){
        System.out.println("I am  fine!");
        return null;
    }
}
public class demo{
    public static void main(String[] args){
        Context<String> context = new Context<>();
        context.setState(new HelloState());
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
    }
}

备忘录

记录上一次的状态,方便回滚。很多时候我们是需要记录当前的状态,这样做的目的就是为了允许用户取消不确定或者错误的操作,恢复到原先的状态

  • 缺点:消耗资源。如果类的成员变量过多,势必会占用比较大的资源,而且每一次保存都会消耗一定的内存

@Data
public class Memento { 
    private String state;
    public Memento(String state){ this.state = state; }
}
@Data
public class Storage { 
    private String value;  
    public void storeMemento(){
        return new Memento(value);  
    }
    public void restoreMemento(Memento memento){  
        this.value = memento.getValue();  
    }
    public void action(){ System.out.println(" Storage类逻辑运行 ");}
      
}
public class MementoPatternDemo { 
    public static void main(String[] args){
        Storage storage = new Storage();
        storage.setValue(1);
        storage.storeMemento();//备忘,一下
        storage.action();//....逻辑运行
        restoreMemento(Memento memento);//使用备忘录的恢复状态
    }
}







文章转载自公众号:潜行前行

分类
标签
已于2023-11-27 11:17:35修改
收藏
回复
举报
回复
    相关推荐