💓 博客主页：瑕疵的CSDN主页
📝 Gitee主页：瑕疵的gitee主页
⏩ 文章专栏：《热点资讯》
计算机编程中的设计模式及其在简化复杂系统设计中的应用
- 计算机编程中的设计模式及其在简化复杂系统设计中的应用
- 引言
- 设计模式概述
- 什么是设计模式
- 设计模式的优势
- 设计模式的分类
- 创建型模式
- 1. 单例模式（Singleton Pattern）
- 2. 工厂方法模式（Factory Method Pattern）
- 3. 抽象工厂模式（Abstract Factory Pattern）
- 结构型模式
- 1. 适配器模式（Adapter Pattern）
- 2. 装饰器模式（Decorator Pattern）
- 3. 代理模式（Proxy Pattern）
- 行为型模式
- 1. 观察者模式（Observer Pattern）
- 2. 策略模式（Strategy Pattern）
- 3. 命令模式（Command Pattern）
- 设计模式在简化复杂系统设计中的应用
- 1. 提高代码的可维护性和可扩展性
- 2. 降低系统的耦合度
- 3. 提高代码的重用性
- 4. 促进团队协作
- 5. 解决复杂的设计问题
- 实际案例：使用设计模式简化一个电子商务系统的开发
- 1. 使用单例模式管理数据库连接
- 2. 使用工厂方法模式创建订单
- 3. 使用适配器模式集成第三方支付系统
- 4. 使用观察者模式处理订单状态变化
- 5. 使用策略模式处理不同的支付方式
- 结论
- 参考资料
设计模式是在软件设计过程中总结出来的一些通用解决方案，旨在解决常见的设计问题。通过使用设计模式，可以简化复杂系统的开发，提高代码的可维护性和可扩展性。本文将详细介绍设计模式的基本概念、分类、实现方式以及在简化复杂系统设计中的应用。
设计模式是在软件设计过程中总结出来的一些通用解决方案，旨在解决常见的设计问题。设计模式不是具体的代码，而是解决问题的一种模板或蓝图。
- 重用性：设计模式提供了解决常见问题的通用方法，可以重复使用。
- 可维护性：使用设计模式可以使代码结构更加清晰，易于维护。
- 可扩展性：设计模式可以提高系统的可扩展性，便于未来的修改和扩展。
- 团队协作：设计模式提供了一种共同的语言，便于团队成员之间的沟通和协作。
设计模式通常分为三类：
- 创建型模式：关注对象的创建过程，提供了一种创建对象的最佳方式。
- 结构型模式：关注类或对象的组合，提供了一种将类或对象组合成更大的结构的方法。
- 行为型模式：关注对象之间的职责分配，提供了一种定义对象之间交互的方式。
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。
public abstract class Creator {
public abstract Product factoryMethod();
public void doSomething() {
Product product = factoryMethod();
product.use();
}
}
public class ConcreteCreator extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProduct();
}
}
public interface Product {
void use();
}
public class ConcreteProduct implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProduct");
}
}
抽象工厂模式提供了一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
public interface ProductA {
void useA();
}
public interface ProductB {
void useB();
}
public class ConcreteProductA1 implements ProductA {
@Override
public void useA() {
System.out.println("Using ConcreteProductA1");
}
}
public class ConcreteProductB1 implements ProductB {
@Override
public void useB() {
System.out.println("Using ConcreteProductB1");
}
}
public class ConcreteProductA2 implements ProductA {
@Override
public void useA() {
System.out.println("Using ConcreteProductA2");
}
}
public class ConcreteProductB2 implements ProductB {
@Override
public void useB() {
System.out.println("Using ConcreteProductB2");
}
}
适配器模式将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
System.out.println("Specific Request");
}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
public class Client {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target target = new Adapter(adaptee);
target.request();
}
}
装饰器模式允许向一个对象动态地添加功能，而不影响该对象所属类的其他对象。
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent Operation");
}
}
public abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
private void addedBehavior() {
System.out.println("Added Behavior A");
}
}
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
private void addedBehavior() {
System.out.println("Added Behavior B");
}
}
public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decoratedA = new ConcreteDecoratorA(component);
Component decoratedB = new ConcreteDecoratorB(decoratedA);
decoratedB.operation();
}
}
代理模式为其他对象提供一种代理以控制对这个对象的访问。
public interface Subject {
void request();
}
public class RealSubject implements Subject {
@Override
public void request() {
System.out.println("RealSubject Request");
}
}
public class Proxy implements Subject {
private RealSubject realSubject;
@Override
public void request() {
if (realSubject == null) {
realSubject = new RealSubject();
}
preRequest();
realSubject.request();
postRequest();
}
private void preRequest() {
System.out.println("Pre Request");
}
private void postRequest() {
System.out.println("Post Request");
}
}
public class Client {
public static void main(String[] args) {
Subject proxy = new Proxy();
proxy.request();
}
}
观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
import java.util.ArrayList;
import java.util.List;
public interface Observer {
void update(String message);
}
public interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(String message);
}
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
public class ConcreteObserver implements Observer {
@Override
public void update(String message) {
System.out.println("Received: " + message);
}
}
public class Client {
public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();
subject.registerObserver(observer1);
subject.registerObserver(observer2);
subject.notifyObservers("Hello Observers");
}
}
策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互换。策略模式让算法的变化独立于使用算法的客户。
public interface Strategy {
void execute();
}
public class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("Executing Strategy A");
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
System.out.println("Executing Strategy B");
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
public class Client {
public static void main(String[] args) {
Context context = new Context(new ConcreteStrategyA());
context.executeStrategy();
context.setStrategy(new ConcreteStrategyB());
context.executeStrategy();
}
}
命令模式将请求封装成对象，从而使不同的请求可以有不同的参数，也可以将请求排队。命令模式支持可撤销的操作。
public interface Command {
void execute();
}
public class Receiver {
public void action() {
System.out.println("Receiver Action");
}
}
public class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.action();
}
}
public class Invoker {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void invoke() {
command.execute();
}
}
public class Client {
public static void main(String[] args) {
Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
Invoker invoker = new Invoker();
invoker.setCommand(command);
invoker.invoke();
}
}
设计模式提供了一种结构化的方式来组织代码，使得代码更加模块化和易于维护。通过使用设计模式，可以更容易地进行代码的扩展和修改。
设计模式通过抽象和封装，降低了系统各部分之间的耦合度，使得系统更加灵活和可复用。
设计模式提供了解决常见问题的通用方法，可以重复使用这些方法，减少重复代码的编写。
设计模式提供了一种共同的语言，便于团队成员之间的沟通和协作。通过使用设计模式，团队成员可以更快地理解彼此的代码。
设计模式提供了一种系统化的方法来解决复杂的设计问题，使得开发人员可以更专注于业务逻辑的实现。
假设我们正在开发一个电子商务系统，需要处理用户订单、支付和物流等复杂功能。以下是具体的步骤和代码示例：
使用单例模式确保数据库连接只有一个实例，提高性能和资源利用率。
public class DatabaseConnection {
private static DatabaseConnection instance;
private Connection connection;
private DatabaseConnection() {
// 初始化数据库连接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/ecommerce", "user", "password");
}
public static DatabaseConnection getInstance() {
if (instance == null) {
synchronized (DatabaseConnection.class) {
if (instance == null) {
instance = new DatabaseConnection();
}
}
}
return instance;
}
public Connection getConnection() {
return connection;
}
}
使用工厂方法模式创建不同类型的订单，提高代码的可扩展性。
public abstract class OrderFactory {
public abstract Order createOrder();
}
public class DomesticOrderFactory extends OrderFactory {
@Override
public Order createOrder() {
return new DomesticOrder();
}
}
public class InternationalOrderFactory extends OrderFactory {
@Override
public Order createOrder() {
return new InternationalOrder();
}
}
public interface Order {
void placeOrder();
}
public class DomesticOrder implements Order {
@Override
public void placeOrder() {
System.out.println("Placing domestic order");
}
}
public class InternationalOrder implements Order {
@Override
public void placeOrder() {
System.out.println("Placing international order");
}
}
public class Client {
public static void main(String[] args) {
OrderFactory factory = new DomesticOrderFactory();
Order order = factory.createOrder();
order.placeOrder();
}
}
使用适配器模式将第三方支付系统的接口适配到系统的支付接口，提高系统的灵活性。
public interface PaymentGateway {
void processPayment(double amount);
}
public class ThirdPartyPaymentSystem {
public void makePayment(double amount) {
System.out.println("Processing payment of $" + amount + " via third-party system");
}
}
public class PaymentAdapter implements PaymentGateway {
private ThirdPartyPaymentSystem thirdPartyPaymentSystem;
public PaymentAdapter(ThirdPartyPaymentSystem thirdPartyPaymentSystem) {
this.thirdPartyPaymentSystem = thirdPartyPaymentSystem;
}
@Override
public void processPayment(double amount) {
thirdPartyPaymentSystem.makePayment(amount);
}
}
public class Client {
public static void main(String[] args) {
ThirdPartyPaymentSystem thirdPartyPaymentSystem = new ThirdPartyPaymentSystem();
PaymentGateway paymentGateway = new PaymentAdapter(thirdPartyPaymentSystem);
paymentGateway.processPayment(100.0);
}
}
使用观察者模式监听订单状态的变化，并通知相关的组件进行相应的处理。
import java.util.ArrayList;
import java.util.List;
public interface OrderStatusObserver {
void onOrderStatusChanged(Order order);
}
public interface OrderStatusSubject {
void registerObserver(OrderStatusObserver observer);
void removeObserver(OrderStatusObserver observer);
void notifyObservers(Order order);
}
public class Order implements OrderStatusSubject {
private List<OrderStatusObserver> observers = new ArrayList<>();
private String status;
@Override
public void registerObserver(OrderStatusObserver observer) {
observers.add(observer);
}
@Override
public void removeObserver(OrderStatusObserver observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(Order order) {
for (OrderStatusObserver observer : observers) {
observer.onOrderStatusChanged(order);
}
}
public void setStatus(String status) {
this.status = status;
notifyObservers(this);
}
}
public class OrderStatusLogger implements OrderStatusObserver {
@Override
public void onOrderStatusChanged(Order order) {
System.out.println("Order status changed to: " + order.getStatus());
}
}
public class Client {
public static void main(String[] args) {
Order order = new Order();
OrderStatusObserver logger = new OrderStatusLogger();
order.registerObserver(logger);
order.setStatus("Processing");
order.setStatus("Shipped");
}
}
使用策略模式根据不同的支付方式选择不同的支付策略，提高系统的灵活性。
public interface PaymentStrategy {
void pay(double amount);
}
public class CreditCardStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("Paying $" + amount + " using credit card");
}
}
public class PayPalStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("Paying $" + amount + " using PayPal");
}
}
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void processPayment(double amount) {
strategy.pay(amount);
}
}
public class Client {
public static void main(String[] args) {
PaymentContext context = new PaymentContext(new CreditCardStrategy());
context.processPayment(100.0);
context.setStrategy(new PayPalStrategy());
context.processPayment(200.0);
}
}
设计模式是在软件设计过程中总结出来的一些通用解决方案，旨在解决常见的设计问题。通过使用设计模式，可以简化复杂系统的开发，提高代码的可维护性和可扩展性。本文详细介绍了设计模式的基本概念、分类、实现方式以及在简化复杂系统设计中的应用，并通过一个实际案例展示了如何使用设计模式简化一个电子商务系统的开发。尽管设计模式面临一些挑战，但随着技术的不断进步，设计模式在现代软件开发中的应用将越来越广泛。
- Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides
- Head First Design Patterns by Eric Freeman and Elisabeth Robson
- Refactoring to Patterns by Joshua Kerievsky
- Design Patterns in Modern JavaScript by Adam Boduch
- Gang of Four (GoF) Design Patterns
