后端思维篇：如何应用设计模式优化代码("后端开发实战：运用设计模式高效优化代码")

原创

ithorizon 6个月前 (10-21) 阅读数 27 #后端开发

后端开发实战：运用设计模式高效优化代码

一、设计模式简介

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式可以帮助我们高效地解决软件开发中常见的重复性问题，尽也许缩减损耗代码的可维护性和可扩展性。

二、设计模式分类

设计模式重点分为三类：创建型模式、结构型模式和行为型模式。

创建型模式：重点用于创建对象，重点有单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。

结构型模式：重点用于处理类和对象之间的关系，重点有适配器模式、装饰器模式、代理模式、外观模式和桥接模式。

行为型模式：重点用于处理对象之间的通信，重点有策略模式、模板方法模式、观察者模式、状态模式和命令模式。

三、应用设计模式优化代码实例

3.1 单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。

场景：数据库连接池、线程池、配置对象等。


public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3.2 工厂模式

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。

场景：日志记录器、数据库连接等。


public interface Logger {
    void log(String message);
}
public class FileLogger implements Logger {
    public void log(String message) {
        System.out.println("File Logger: " + message);
    }
}
public class DatabaseLogger implements Logger {
    public void log(String message) {
        System.out.println("Database Logger: " + message);
    }
}
public class LoggerFactory {
    public static Logger getLogger(String type) {
        if ("file".equals(type)) {
            return new FileLogger();
        } else if ("database".equals(type)) {
            return new DatabaseLogger();
        }
        throw new IllegalArgumentException("Unknown logger type");
    }
}

3.3 装饰器模式

装饰器模式动态地给一个对象添加一些额外的职责，而不改变其接口。

场景：输入/输出流处理、文本编辑器等。


public interface Component {
    void operation();
}
public class ConcreteComponent implements Component {
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}
public abstract class Decorator implements Component {
    protected Component component;
    public Decorator(Component component) {
        this.component = component;
    }
    public void operation() {
        component.operation();
    }
}
public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorA operation");
    }
}
public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorB operation");
    }
}

3.4 策略模式

策略模式定义一系列算法，将每一个算法封装起来，并使它们可以互相替换。

场景：排序算法、支付方案等。


public interface Strategy {
    int doOperation(int num1, int num2);
}
public class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}
public class OperationSubtract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

3.5 观察者模式

观察者模式定义了一种一对多的依靠关系，当一个对象改变状态时，所有依靠于它的对象都会得到通知并自动更新。

场景：事件监听、股票价格监控等。


public interface Observer {
    void update();
}
public class ConcreteObserver implements Observer {
    private int value;
    public void update() {
        System.out.println("ConcreteObserver: " + value);
    }
    public void setValue(int value) {
        this.value = value;
    }
}
public class Subject {
    private List observers = new ArrayList<>();
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}