一文搞懂常用设计模式：提升代码架构的必备指南

发表于 2025-5-7 17:22:58

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

引言

在软件开发领域，设计模式是开发者们用来构建高效、可维护和可扩展代码的有力工具。只管设计模式种类繁多，但此中一些模式在一样平常开发中频繁使用，它们能解决各种常见问题，从对象创建到布局组织，再到行为交互。把握这些常用设计模式，如同拥有一套万能钥匙，能帮助我们轻松应对软件开发过程中的诸多挑衅。接下来，让我们深入探讨这些常用设计模式的原理与应用。
单例模式（Singleton Pattern）

模式界说与原理

确保一个类仅有一个实例，并提供一个全局访问点。其核心原理是通过将构造函数私有化，阻止外部直接实例化，同时提供一个静态方法来获取唯一的实例。
实现方式

饿汉式

public class Singleton {
// 在类加载时就创建唯一实例
private static final Singleton instance = new Singleton();
// 私有构造函数，防止外部实例化
private Singleton() {}
// 提供全局访问该实例的方法
public static Singleton getInstance() {
return instance;
}
}

复制代码

这种方式简单直接，类加载时实例就已创建，自然线程安全，但大概造成资源浪费，如果实例不停未被使用。
懒汉式（线程安全）

public class Singleton {
// 声明实例，但延迟初始化
private static volatile Singleton instance;
// 私有构造函数，防止外部实例化
private Singleton() {}
// 提供全局访问该实例的方法，采用双重检查锁确保线程安全
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

复制代码

懒汉式实现了延迟加载，只有在第一次使用时才创建实例。双重检查锁机制包管了在多线程环境下的线程安全性，同时制止了不必要的同步开销。
应用场景

实用于资源管理器类型的场景，如数据库连接池、日志

记载器等。以数据库连接池为例，多个模块大概都必要获取数据库连接，如果每个模块都创建自己的连接池实例，会造成资源浪费和管理混乱。使用单例模式，整个应用步伐只有一个数据库连接池实例，既节省资源又便于统一管理。
工厂模式（Factory Pattern）

模式界说与原理

将对象的创建和使用分离，通过一个工厂类来负责创建对象。它基于一个抽象的创建接口，由详细的工厂子类决定创建何种详细对象。如许，当必要创建新的对象类型时，只需在工厂类中添加相应的创建逻辑，而无需修改大量的客户端代码，提高了代码的可维护性和可扩展性。
工厂方法模式示例

// 产品接口，定义产品的通用行为
interface Product {
void use();
}
// 具体产品A，实现产品接口
class ProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 抽象工厂类，定义创建产品的抽象方法
abstract class Factory {
// 抽象方法，由子类实现具体的产品创建逻辑
abstract Product createProduct();
}
// 具体工厂A，继承抽象工厂类并实现创建产品A的逻辑
class ConcreteFactoryA extends Factory {
@Override
Product createProduct() {
return new ProductA();
}
}

复制代码

在客户端代码中：

public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactoryA();
Product product = factory.createProduct();
product.use();
}
}

复制代码

应用场景

在电商体系中，不同类型商品的创建可以使用工厂模式。比方，创建实体商品和虚拟商品，它们的创建过程大概涉及不同的初始化操作，通过工厂模式可以将这些复杂的创建逻辑封装在工厂类中，客户端只需调用工厂方法获取商品实例，无需关心详细的创建细节。
署理模式（Proxy Pattern）

模式界说与原理

为其他对象提供一种署理以控制对这个对象的访问。署理对象与真实对象实现相同的接口，客户端通过署理对象访问真实对象，署理对象可以在调用真实对象的方法前后添加额外的逻辑，如权限验证、日志

记载等。
示例代码

// 主题接口，定义真实主题和代理主题的共同接口
interface Subject {
void request();
}
// 真实主题类，实现主题接口
class RealSubject implements Subject {
@Override
public void request() {
System.out.println("真实主题执行请求");
}
}
// 代理类，持有真实主题的引用，并实现主题接口
class Proxy implements Subject {
private RealSubject realSubject;
// 构造函数，传入真实主题对象
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
@Override
public void request() {
// 在调用真实主题的方法前，可以进行一些预处理操作，如权限验证
System.out.println("代理进行权限验证");
realSubject.request();
// 在调用真实主题的方法后，可以进行一些后处理操作，如日志记录
System.out.println("代理记录请求日志");
}
}

复制代码

在客户端代码中：

public class Client {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
Proxy proxy = new Proxy(realSubject);
proxy.request();
}
}

复制代码

应用场景

在远程服务调用中，署理模式常用于创建远程署理。客户端通过远程署理对象调用远程服务，署理对象负责处理网络通信、序列化 / 反序列化等复杂操作，对客户端隐藏了远程调用的细节。比方，调用第三方付出接口时，使用署理模式可以在调用前后添加参数校验、记载付出日志等功能。
观察者模式（Observer Pattern）

模式界说与原理

界说了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，会通知全部观察者对象，使它们可以或许自动更新。
示例代码

// 主题接口，定义注册、移除和通知观察者的方法
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
// 观察者接口，定义更新方法
interface Observer {
void update();
}
// 具体主题类，实现主题接口
class ConcreteSubject implements Subject {
private java.util.List<Observer> observers = new java.util.ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
// 模拟主题状态变化的方法
public void changeState() {
System.out.println("主题状态发生变化");
notifyObservers();
}
}
// 具体观察者类，实现观察者接口
class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println("观察者收到通知并更新");
}
}

复制代码

在客户端代码中：

public class Client {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
ConcreteObserver observer = new ConcreteObserver();
subject.registerObserver(observer);
subject.changeState();
}
}

复制代码

计谋模式（Strategy Pattern）

模式界说与原理

界说一系列算法，将每个算法都封装起来，而且使它们可以相互更换。计谋模式让算法的变化独立于使用算法的客户。通过将不同的算法封装成详细的计谋类，客户端可以根据不同的需求选择不同的计谋。
示例代码

// 策略接口，定义算法的抽象方法
interface Strategy {
void execute();
}
// 具体策略A，实现策略接口
class StrategyA implements Strategy {
@Override
public void execute() {
System.out.println("执行策略A");
}
}
// 具体策略B，实现策略接口
class StrategyB implements Strategy {
@Override
public void execute() {
System.out.println("执行策略B");
}
}
// 上下文类，持有策略接口的引用
class Context {
private Strategy strategy;
// 构造函数，传入具体的策略对象
public Context(Strategy strategy) {
this.strategy = strategy;
}
// 执行策略的方法
public void executeStrategy() {
strategy.execute();
}
}

复制代码

在客户端代码中：

public class Client {
public static void main(String[] args) {
Strategy strategyA = new StrategyA();
Context context = new Context(strategyA);
context.executeStrategy();
Strategy strategyB = new StrategyB();
context = new Context(strategyB);
context.executeStrategy();
}
}

复制代码

应用场景

在电商体系的促销运动中，不同的促销计谋（如满减、扣头、赠品等）可以使用计谋模式实现。体系可以根据不同的运动类型选择相应的促销计谋，使得促销逻辑易于扩展和维护。
装饰器模式（Decorator Pattern）

模式界说与原理

动态地给一个对象添加一些额外的职责。装饰器模式通过组合的方式，让装饰对象持有被装饰对象的引用，并实现与被装饰对象相同的接口。在调用装饰对象的方法时，会先调用被装饰对象的方法，然后实行装饰对象添加的额外逻辑，从而在不改变原有对象布局的情况下为其添加新功能。
示例代码

// 组件接口，定义组件的基本行为
interface Component {
void operation();
}
// 具体组件类，实现组件接口
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("具体组件的操作");
}
}
// 装饰器抽象类，继承组件接口并持有组件实例
abstract class Decorator implements Component {
protected Component component;
// 构造函数，传入组件实例
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
// 具体装饰器类，继承装饰器抽象类并添加额外功能
class ConcreteDecorator extends Decorator {
// 构造函数，传入组件实例
public ConcreteDecorator(Component component) {
super(component);
}
@Override
public void operation() {
// 先执行原有组件的操作
super.operation();
// 添加额外的操作
System.out.println("具体装饰器添加的额外操作");
}
}

复制代码

在客户端代码中：

public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decoratedComponent = new ConcreteDecorator(component);
decoratedComponent.operation();
}
}

复制代码

应用场景

在 Java 的 I/O 流中，装饰器模式得到了广泛应用。比方，BufferedInputStream就是对InputStream的装饰，它为InputStream添加了缓冲功能，提高了读取效率。在实际开发中，如果必要在运行时为对象动态添加功能，如给游戏角色添加临时增益效果，就可以使用装饰器模式。
总结

这些常用设计模式在软件开发中各自发挥侧重要作用，无论是创建对象、管理对象关系，还是处理对象行为，它们都提供了优雅且高效的解决方案。通过深入明确和纯熟运用这些设计模式，开发者可以或许构建出更加健壮、可维护和可扩展的软件体系。盼望本文的介绍能帮助你在实际项目中更好地应用这些设计模式，提升代码质量与开发效率。你在使用这些设计模式时有什么独特的经验或问题吗？欢迎在批评区分享交换。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

一文搞懂常用设计模式：提升代码架构的必备指南

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

冬雨财经