【零】Java设计模式GOF23之总结

最新推荐文章于 2022-03-24 21:14:14 发布

jy02268879

最新推荐文章于 2022-03-24 21:14:14 发布

阅读量496

点赞数

分类专栏： GOF23(Java设计模式) 文章标签：设计模式 GOF23

本文链接：https://blog.csdn.net/jy02268879/article/details/81628195

版权

GOF23(Java设计模式) 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

设计模式主要有3个大分类

创建型模式：用来建造对象

一、单例模式：

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

常见应用场景：

1.全局计数器采用单例模式，不然不好同步。

2.应用程序的日志应用，共享日志文件一直处于打开状态，所以只能有一个实例去操作，否则内容不好追加。

3.数据库连接池的设计也用单例，否则浪费资源。

4.spring中的bean默认都是单例。

5.servlet是单例。

6.spring mvc/ structs1，控制器对象是单例。

7.项目中工具类，一般都用单例，没必要浪费资源。

常见实现方式

1.饿汉模式（线程安全、调用效率高、不能延时加载）

2.懒汉模式（线程安全、调用效率不高（getInstance方法用了synchronized同步方法）、可以延时加载）

3.静态内部类模式（线程安全、调用率高、可以延时加载）

4.双重同步锁单例模式

5.枚举单例（线程安全、调用率高、不能延时加载、不会被反射反序列化生成多个实例）

代码

各种单例模式代码演示

UML图

二、工厂模式

选择实现类、创建对象统一管理和控制。

实现了创建者和调用者的分离。

用工厂方法代替new操作。

常见应用场景：

1.JDK中Calendar的getInstance方法

2.JDBC中Connection对象的获取

3.Hibernate中SessionFactory创建session对象

4.spring中IOC容器创建管理bean对象

5.反射中Class对象的newInstance

6.JDK中java.util.concurrent包中的Executors类，就是一个静态工厂，用来创建各种线程池。代码示例用这个案例

1.简单工厂模式

用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）

代码

【十】Java设计模式GOF23之简单工厂模式(静态工厂模式)

UML图

源码中间多了一层抽象AbstractExecutorService，在普通的静态工厂中是不需要这层抽象的。

2.工厂方法模式

用来生产同一等级结构中的固定产品。（支持增加任意产品）

代码

【十一】Java设计模式GOF23之工厂方法模式

UML图

3.抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的单个产品，无能为力，支持增加产品族）

它是工厂方法模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

代码

【十二】Java设计模式GOF23之抽象工厂模式

UML图

三、建造者模式

分离了对象子组件的单独构造（有builder来负责）和装配（由Director负责）。从而可以构造出复杂的对象。

这个模式适用于：某个对象的构建过程复杂的情况下。

由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。

也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

常见应用场景：

1.SpringBuilder类的append方法

2.SQL中的PreparedStatement

3.JDOM中的DomBuilder、SAXBuilder

4.去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

之前遇到一个笔试题应该就是考构建者模式的，例子是说的星巴克。“咖啡价格问题：星巴克咖啡有基本的美式，摩卡，拿铁三种，价格都不一样。同时有很多的配料，包括香草、肉桂、奶油、焦糖、巧克力，每种配料的价格也不一样。一种咖啡可以选多种配料。以OOD的方式来计算每杯咖啡的价格。”

代码

【五】Java设计模式GOF23之建造者模式

UML图

四、原型模式prototype

如果通过new创建一个对象需要非常繁琐的数据准备和访问权限，则可以用原型模式。

就是java中的克隆，以某个对象为原型，复制出新对象。新对象具备原型对象的特点。

优势：效率高（直接克隆，避免了重新执行构造过程步骤）

代码

【十四】Java设计模式GOF23之原型模式

结构型模式：

一、适配器模式

将一个类的接口转换成客户希望的另外一个接口。

适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。一个系统如果太多出现这种情况，无异于一场灾难。

类适配器用继承实现

对象适配器用依赖实现

代码

【十】Java设计模式GOF23之适配器模式（类方式实现、对象方式实现）

个人思考：这个设计模式不是很鸡肋吗，还是我没理解到它的精髓？

直接用adaptee去实现target接口，在request方法中写自己的specificRequest方法的逻辑就好了啊，为毛要多个adapter类出来？

什么毛病？

UML图

二、桥接模式

它的主要特点是把抽象（abstraction）与行为实现（implementation）分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展

适用处理多维度变化。

举个例子，引用例子Java 设计模式之桥接模式（七）

这个例子里面，电脑类型是一个维度，电脑品牌是一个维度，把品牌放在类型下面，那么类型的增加会导致品牌的增加。

品牌的增加，也会去每个类型下面增加一个对象。

桥接模式的意思就是，以上面这个例子来说，应该提两个维度的接口或父类出来，他们之间可以考虑依赖的方式。这样一个维度变更不影响另外一个维度。比如：

三、装饰模式

四、组合模式

五、外观模式

六、享元模式

七、代理模式

核心作用：通过代理，控制对对象的访问。

可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（Spring AOP的围观实现）。从而实现将统一流程代码放到代理类中处理。

应用场景：

1.安全代理：屏蔽对真实角色的直接访问

2.远程代理：通过代理类处理远程方法调用RMI

3.延迟加载：先加载轻量级的代理对象，真正需要时再加载真实对象

1.静态代理

自己定义代理类

代码

【十五】Java设计模式GOF23之静态代理

UML图

2.动态代理

动态生成代理类

代码

这里使用反射来实现的

【十六】Java设计模式GOF23之动态代理

UML图

行为型模式：

一、模板方法模式

java.util.AbstractQueuedSynchronizer类的设计就使用了模板方法模式。

代码

父类AQS，写了释放锁的逻辑release()方法，

而release()方法中有部分逻辑是需要调用tryRelease()方法实现:

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

父类AQS并没有实现tryRelease()方法，而是由子类Sync去实现自己的tryRelease()方法。

父类描述了整体的释放锁的逻辑，部分细节由子类描述，不同的子类有不同的描述。

比如ReentrantLock中的Sync的tryRelease()

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

countDownLatch中的Sync的tryRelease()

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

【二十一】Java多线程J.U.C之AQS框架源码导读（总结、干货）（模板模式template pattern）

UML图

二、命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

JDK的java.util.concurrent包的ThreadPoolExecutor类就用到命令模式。

简易命令模式组成
1.Command(抽象命令类)：声明了用于执行请求的的exceute()等方法

2.ConcreteCommand（具体命令类）：抽象命令类的子类，对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作(Action)。

3.Invoker(调用者)：调用命令对象执行请求，它持有了一个命令队列，客户端代码可以向它提交要执行的任务（命令）。

4.Receiver(接收者)：真正的命令执行对象。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。
UML图

代码

【十三】Java设计模式GOF23之命令模式（例子ThreadPoolExecutor类）

三、迭代器模式

简介

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

它提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要成员

1.抽象容器：一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。
2.具体容器：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。
3.抽象迭代器：定义遍历元素所需要的方法，一般来说会有这么三个方法：取得第一个元素的方法first()，取得下一个元素的方法next()，判断是否遍历结束的方法isDone()（或者叫hasNext()），移出当前对象的方法remove(),
4.迭代器实现：实现迭代器接口中定义的方法，完成集合的迭代。
UML图