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

老老老JR老北

发布于 2023-11-27 11:17

浏览

0收藏

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

创建型

单例模式

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

优点

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

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

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

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

缺点

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

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

//懒汉式
private static Singleton singleton;
public static Singleton getSingleton(){
    if (singleton == null) {
        singleton = new Singleton(); //被动创建，在真正需要使用时才去创建
    }
    return singleton;
}1.
2.
3.
4.
5.
6.
7.
8.

//双重判断加锁机制
private volatile static Singleton instance;
//程序运行时创建一个静态只读的进程辅助对象
public static Singleton GetInstance(){
    //先判断是否存在，不存在再加锁处理
    if (instance == null){
        synchronized (Singleton.class){
            if(instance == null){
                instance = new Singleton();
            }
        }
    }
    return instance;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

//静态初始化
private static readonly Singleton instance= new Singleton();
public static Singleton GetInstance(){
    return instance;
}1.
2.
3.
4.
5.

工厂模式

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

优点

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

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

缺点

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

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 方法
}  1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

建造者模式

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

优点

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

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

缺点

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

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

@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; }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

结构型

适配器模式

连通上下游功能。一般是现有的功能和产品要求的接口不兼容，需要做转换适配。平时见到的 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!");  
    }  
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

//对象的适配器模式
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!");  
    }  
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

装饰器模式

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

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.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

代理模式

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

和装饰器模式的区别：代理模式着重于增强类功能，且对面屏蔽原对象的创建过程；装饰器模式增强的是对象，且装饰器模式有一个动态传递原对象的步骤
和对象的适配器模式优点像：不过代理模式着重的是对原功能增强，适配器模式着重的是对新功能的兼容
优点-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();
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

桥接模式

桥接模式侧重于功能的抽象，从而基于这些抽象接口构建上层功能。一般的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);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

可配合适配器模式使用

享元模式

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

如 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);
            }
    }
    ....
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

外观模式

用多个不同的对象实现一组更复杂的功能。使得类与类之间的关系解耦。如 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();
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

行为型

策略模式

策略模式侧重于不同的场景使用不同的策略。在有多种算法相似的情况下，解决 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();
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

模板方法

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

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

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);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

迭代子模式

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

//迭代的抽象接口
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;
    }  
}  1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

责任链模式

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

和迭代子模式的区别，责任链模式是多个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");
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

观察者模式

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

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

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

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

//观察者
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);
        }
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

状态机模式

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

和策略模式的区别

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

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

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");
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.

备忘录

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

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

@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);//使用备忘录的恢复状态
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

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

分类

其他

标签

JAVA

MYSQL

已于2023-11-27 11:17:35修改

51CTO

51CTO博客

51CTO学堂