Java开发设计模式

奔跑匠人

已于 2023-03-05 23:49:58 修改

阅读量639

点赞数

分类专栏： JAVA 基础文章标签： java 设计模式单例模式

于 2022-12-05 00:20:08 首次发布

本文链接：https://blog.csdn.net/qq_20481597/article/details/128179702

版权

JAVA 基础专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1 设计模式7大原则
2 创建型模式（5种）
3 结构型模式（7种）
4行为模式（12种）

1 设计模式7大原则

开闭原则：对扩展开放、对修改关闭。
单一职责原则：一个类只做一件事。
依赖倒转原则：类似于ioc，采用接口编程。
迪米特原则：高内聚，低耦合。
接口隔离原则：应该使用多个接口，而不是用单一的总接口。
合成复用原则：尽量使用对象组合，而不是继承来达到复用目的。
里氏替换原则：子类可以扩展父类的功能，但不能改变原有的功能。

2 创建型模式（5种）

2.1.单例模式（Singleton）

保证一个类只有一个实例，并提供一个全局访问点。
实现单例的四种方式：
1.双重锁（懒汉模式）

public class LazySingleton {
    private static volatile LazySingleton instance;
    //不允许被实例化
    private LazySingleton(){
    }
    /**
     * 获取实例
     * @return
     */
    public static LazySingleton getInstance() {
        if(instance!=null){
            synchronized (LazySingleton.class){
                if(instance!=null) {
                    instance = new LazySingleton();
                    /*一个new操作在字节码层面对应三步操作
                    * 1、开辟空间
                    * 2、初始化
                    * 3、变量赋值
                    * cpu可能会重排需2、3步。如果先执行了第3步，则会返回一个没有初始化的对象，
                    * 发生空指针异常。增加volatile关键字，防止重排序
                    * */
                }
            }
        }
        return instance;
    }
}

特点：延时加载，只有在正在需要的时候才开始实例化。
线程安全问题。
双重判断double check，加锁优化（锁也可以直接加锁到方法上，但是会耗费性能）。
使用volatile关键字，防止指令重排序。

2.静态变量（饿汉模式）：

class HunglySingleton {
    private static HunglySingleton instance= new HunglySingleton();
    //不允许被实例化
    private HunglySingleton(){
    }
    /**
     * 获取实例
     * @return
     */
    public static HunglySingleton getInstance() {
        return instance;
    }
}

特点：类加载的初始化阶段就完成了实例的初始化，本质上是借助于jvm的类加载机制，保证实例的唯一性。（急加载）
类加载机制：
加载：加载二进制文件到内存中，并生成对应的class数据结构。
连接：包括验证、准备（给静态变量赋默认值，引用类型为null，int为0，boolean为false等等）、解析（将符号应用替换为直接引用）。
初始化（执行静态代码块、给静态变量赋初值）。
注意：如果当前类的父类没有被加载，则会先加载父类。

3.静态内部类（懒加载）：

class InnerSingleton {
    private static class InnerSingletonHolder {
        private static InnerSingleton instance= new InnerSingleton();
    }
    //不允许被实例化
    private InnerSingleton(){
    }
    /**
     * 获取实例
     * @return
     */
    public static InnerSingleton getInstance() {
        return InnerSingletonHolder.instance;
    }
}

特点：也是借助jvm的类加载机制，保证实例的唯一性（懒加载）。
当访问instance时才会初始化实例。

4.enum模式

enum  EnumSingleton {
    INSTANCE;
    /**
     * 获取实例
     * @return
     */
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

特点：简单，线程安全，也能够防护反射攻击（禁止反射实例化enum类型类）

Spring中的单例例子：
DefaultSingletonBeanRegistry、ReactiveAdapterRegistry、ProxyFactoryBean(aop包)。

2.2 工厂模式（Factory）

把对象的创建功能交给工厂，达到解耦目的。
适合场景：

无法预知对象确切类别及依赖关系时，可使用。
希望复用现有对象来节省系统资源，而不是每次都创建对象。

2.3 抽象工厂模式（AbstractFactory）

用于创建一系列相关的对象，而无需指定其具体类。
适合场景：

如果代码需要与多个不同系列的相关产品交互，由于无法提前获取相关信息或未来扩展考虑，不希望代码基于产品的具体类来进行构建的情况下使用。
希望复用现有对象来节省系统资源，而不是每次都创建对象。

用例：spring的BeanFactory。和其他任何用于创建对象但返回接口或抽象类的就是此模式。

2.4 生成器模式（Builder）

定义一个类来简化复杂对象的创建（分步骤创建）。该类是为了构建另一个类的实例。
适合场景：

避免“重叠构造函数”的出现。
当希望用代码创建不同形式的产品时使用。

比如订单系统，订单对象就是一个复杂对象，我们就可以build来做。
用例：SpringApplicationBuilder、StringBuilder

2.5 原型模式（Prototype）

使你能够复制已有对象，而又无需使代码依赖它们所属的类。
适合场景：

创建一个对象的实例非常复杂且耗时时可以使用。

例如我们的DTO、BO、DO、VO转换时可以使用。
用例：spring的bean有单例模式singleton和原型模式prototype（scope=prototype）

3 结构型模式（7种）

3.1 代理模式（Proxy）

代理控制着对于原对象的访问（不能直接访问原对象），并允许在将请求提交给对象前后进行一些处理。
适合场景：

用于保护原对象。
用于增强原对象。

用例：jdk的Proxy类。

3.2 适配器模式（Adapter）

用于新接口和旧接口的适配，使接口不兼容的对象能够相互合作。
适合场景：希望使用某类，但与接口或其他代码不兼容时使用。
用例：springmvc的HandlerAdapter。例如xml转json，可以新增XmlJsonAdapter适配器类内进行转换。

3.3 桥接模式（bridge）

将抽象和抽象的具体实现进行解耦，使得抽象和抽象的具体实现可以进行独立变化。并使用组合的方式将多维度的抽象方法联系在一起。
适合场景：

想要拆分或重组一个具有多重功能的庞杂类（例如多个能与数据交互的类）可使用。
想在几个纬度上扩展类。
想要在运行是切换不同实现方法。

3.4 组合模式(composite)

可以使用它将对象组合成树状结构，以表示“部分-整体”的层次结构，并且能像使用独立对象一样使用它们。
让客户端看起来在处理单个对象和对象的组合是平等的，换句话说，某个类型的方法同时也接受自身类型作为参数。例如Map的putAll（Map）方法。
适合场景：

需要实现树状对象结构时。
希望客户端代码以相同方式处理简单和复杂元素时。
常用于递归操作的优化上。

3.5 外观模式/门面模式（Facade）

为一组接口、抽象类或子系统提供简化的接口。并且要求一个子系统的外部与其内部的通信必须通过一个统一的Facade对象进行。
Facade模式提供一个高层次的接口，使得子系统更易于使用。
适合场景：

需要一个指向复杂子系统的直接接口，但使用的功能有限时。
子系统组织为多层结构时。
保护子系统的接口，可以使用门面模式只提供某些接口，不提供全部。
使用Dubbo，向外提供的服务就尽量采用门面模式，然后服务在调用各种service做聚合。

实例：tomcat的RequestFacade、SLFJ日志就是门面日志。

3.6.装饰模式(Decorator/Wapper)

你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。相当于动态的给一个对象附加额外的功能，因此它也是子类化的一种替代方法。（就是在不继承的情况下，扩展类的功能）

实例：tomcat对request的包装ServletRequestWrapper、所有的io流包装类。

3.7 享元模式(Flyweight)

它摒弃了在每个对象中保存所有数据的方式，通过共享多个对象所共有的相同状态，让你能在有限的内存容量中载入更多对象。

简单来说就是使用缓存来减小对象的访问时间（使用共享技术实现元素的共享）
适合场景：程序必须支持大量对象且没有足够的内存容量时使用（共享变量）
实例：只要用到了缓存，基本都是在使用享元模式。

4行为模式（12种）

4.1 责任链模式（Chain of Responsibility）

将请求沿着处理者链进行发送。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。
可以实现解耦。责任链中的对象是同一接口或抽象类的不同实现。
适合场景：

程序需要用不同的方式处理不同请求，而且请求类型和顺序未知时。
当必须按照顺序执行多个处理者时。
如果所需处理者及其顺序必须在运行时进行改变时。

用例：servler中Filter过滤器、拦截器等。

4.2命令模式（Command）

将命令包装在对象中，以便可以存储、传递到方法中，并像任何其他对象一样返回(以命令动作为类名)。
命令模式可以把发出命令的责任和执行命令的责任分开。
适合场景：

需要通过操作来参数化对象。
想要将操作放入队列中，本地执行操作或远程执行操作时，可以使用。
想要实现操作回滚功能时。

用例：java.lang.Runnable、javax.swing.Action

4.3迭代器模式（Iterator）

让你能在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。
提供一个统一的方式来访问集合中的对象。
适合场景：

当集合背后是复杂的数据结构，希望对客户端隐藏时（处于便利性或安全性）
可以监视程序中重复的遍历代码时。
希望遍历不同，甚至是无法预知的数据结构时。

用例：Iterator、Vector集合、set集合。

4.4 中介模式（Mediator）

能让你减少对象之间混乱无序的依赖关系。该模式会限制对象之间的直接交互，迫使它们通过一个中介者对象进行合作。（用一个中介对象来封装一系列关于对象交互行为）。
即使用一个中间对象来进行消息分发以及减少类之间的直接依赖。
适合场景：

当一些对象或其他对象紧密耦合难以对其进行修改时。
当组件过于依赖其他组件而无法在不同应用中复用时。
如果为了能在不同情景下复用一些基本行为，而导致需要被迫创建大量组件子类时。

用例：mq使用的就是此模式、MVC中的Controller、Executor

4.5备忘录模式（Memento）

允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态。
即生成对象状态的一个快照，以便对象可以恢复原始状态而不用暴露自身的内容。
在不破坏封装性的情况下，捕获并保存一个类的内部状态，可以利用该保存的状态实施恢复操作。
适合场景：

当你需要创建对象状态快照来恢复其之前的状态
当直接访问对象的成员变量、get、set时导致封装被突破时。

用例：
Date对象通过自身内部的一个long值来实现备忘录模式、Serializable

4.6 观察者模式/发布订阅模式（Observer/Listener）

允许你定义一种订阅机制，可在对象事件发生时通知多个 “观察” 该对象的其他对象。
适合场景：

当一个对象的改变需要改变其他对象时，或实际对象时事先未知的或动态变化的时。
当应用中的一些对象必须观察其他对象时。

用例：EventListener、tomcat的LifeCycleListener、使用zookeeper作为观察者，例如分布式锁、服务发现等。

4.7 状态模式（State）

能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样。
即允许您在运行时根据内部状态轻松更改对象的行为。
状态模式重点在各状态之间的切换从而做不同的事情，状态模式不同状态下做的事情不同。
状态模式封装了对象的状态，因为状态是跟对象密切相关的，它不能被重用。
适合场景：

如果对象需要根据自身当前状态进行不同行为，同时状态的数量非常多且与状态相关的代码会频繁变更时。
如果某个类根据成员变量的当前值改变自身行为，从而需要使用大量的条件语句时。
当相似状态和基于状态转换中存在许多重复代码时。

4.8 策略模式（Strategy）

它能让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。
即将一组算法封装成一系列对象。通过调用这些对象可以灵活的改变程序的功能。
策略模式更侧重于根据具体情况选择策略，并不涉及切换。策略模式做的都是同一件事。
策略模式封装算法或策略，通过从Context中分离出策略或算法，我们可以重用它们。
适合场景：

想使用对象中各种不同的算法变体，并希望在运行时切换算法时。
如果算法在上下文的逻辑中不是特别重要，使用该模式能将类的业务逻辑与算法实现细节隔离开来。
当类中使用了复杂条件运算符如：if else，以在同一算法的不同变体中切换时。
可以用策略模式和工厂模式优化程序中过多的if-else。

4.9 模版模式（template）

在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。
即让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作。
适合场景：

只希望客户端扩展某个特定的算法步骤，而不是整个算法或其结构时。
当多个类的算法除了一些细微不同之外几乎完全一样时。

用例：InputStream类的skip或read方法、我们可以做一个抽象类，某个方法需要子类来实现差异化。

4.10 访问者模式（Visitor）

提供一个方便的可维护的方式来操作一组对象。它使得你在不改变操作的对象前提下，可以修改或者扩展对象的行为。
它能将算法与其所作用的对象隔离开来。虽然可以在不改变原有类结构的基础上不断添加新的功能。但是缺点是破坏了封装性。
适合场景：

需要对一个复杂的对象结构（如对象树）中所有的元素执行某些操作时。
可使用此模式来清理辅助行为的业务逻辑。
当某个行为仅在类层次结构中的一些类中有意义，在其他类中没意义时。

3.11 空对象模式（Empty）

它允许抽象空对象的处理。
用例：
Collections类的emptyList()
Collections类的emptyMap()
Collections类的emptySet()

3.12 解释器模式（Interpreter）

通常描述为该语言定义语法并使用该语法来解释该格式的语句。
用例：
Pattern类
Normalizer类
Format类

奔跑匠人

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Java开发设计模式

保证一个类只有一个实例，并提供一个全局访问点。实现单例的四种方式：1.双重锁（懒汉模式）特点：延时加载，只有在正在需要的时候才开始实例化。线程安全问题。双重判断double check，加锁优化（锁也可以直接加锁到方法上，但是会耗费性能）。使用volatile关键字，防止指令重排序。2.静态变量（饿汉模式）：特点：类加载的初始化阶段就完成了实例的初始化，本质上是借助于jvm的类加载机制，保证实例的唯一性。（急加载）类加载机制：加载：加载二进制文件到内存中，并生成对应的class数据结构。
复制链接

扫一扫