知识仓库

RAG 问答

设计模式

8分钟阅读

设计模式

设计模式是解决软件设计常见问题的可复用方案，分为三大类：创建型、结构型、行为型。

创建型

单例模式

确保一个类只有一个实例。

// 双重检查锁（推荐）
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;
    }
}
 
// 静态内部类（推荐，延迟加载 + 线程安全）
public class Singleton {
    private Singleton() {}
 
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
 
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}
 
// 枚举（最简洁，防反射和序列化破坏）
public enum Singleton {
    INSTANCE;
    public void doWork() { }
}

工厂方法模式

定义创建对象的接口，让子类决定实例化哪个类。

public interface Logger {
    void log(String message);
}
 
public abstract class LoggerFactory {
    public abstract Logger createLogger(); // 工厂方法
 
    public void logMessage(String msg) {
        createLogger().log(msg);           // 使用工厂方法
    }
}
 
public class FileLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

抽象工厂模式

创建一系列相关对象（产品族）。

public interface UIFactory {
    Button createButton();
    TextField createTextField();
}
 
public class WindowsUIFactory implements UIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
}
 
public class MacUIFactory implements UIFactory {
    public Button createButton() { return new MacButton(); }
    public TextField createTextField() { return new MacTextField(); }
}

建造者模式

分步骤构建复杂对象，链式调用。

public class User {
    private final String name;
    private final String email;
    private final int age;
 
    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
    }
 
    public static class Builder {
        private final String name;  // 必填
        private String email = "";  // 可选，默认值
        private int age = 0;
 
        public Builder(String name) { this.name = name; }
        public Builder email(String email) { this.email = email; return this; }
        public Builder age(int age) { this.age = age; return this; }
        public User build() { return new User(this); }
    }
}
 
User user = new User.Builder("Alice").email("a@b.com").age(30).build();

原型模式

通过拷贝现有对象创建新对象。

public class Config implements Cloneable {
    private Map<String, String> settings = new HashMap<>();
 
    @Override
    public Config clone() {
        try {
            Config copy = (Config) super.clone();
            copy.settings = new HashMap<>(this.settings); // 深拷贝 Map
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

结构型

代理模式

控制对对象的访问，可在访问前后添加逻辑。

// 静态代理
public class LoggingService implements UserService {
    private final UserService delegate;
 
    public LoggingService(UserService delegate) {
        this.delegate = delegate;
    }
 
    @Override
    public User getUser(Long id) {
        log.info("getUser called with id={}", id);
        User user = delegate.getUser(id);
        log.info("getUser returned: {}", user);
        return user;
    }
}
 
// JDK 动态代理（基于接口）
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    (p, method, args) -> {
        log.info("Before: {}", method.getName());
        Object result = method.invoke(target, args);
        log.info("After: {}", method.getName());
        return result;
    }
);

装饰器模式

动态地为对象添加功能，比继承更灵活。

public interface Coffee {
    String getDescription();
    double getCost();
}
 
public class SimpleCoffee implements Coffee {
    public String getDescription() { return "咖啡"; }
    public double getCost() { return 5.0; }
}
 
public abstract class CoffeeDecorator implements Coffee {
    protected final Coffee coffee;
    public CoffeeDecorator(Coffee coffee) { this.coffee = coffee; }
}
 
public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) { super(coffee); }
    public String getDescription() { return coffee.getDescription() + " + 牛奶"; }
    public double getCost() { return coffee.getCost() + 2.0; }
}
 
// 使用
Coffee c = new MilkDecorator(new SimpleCoffee());
// c = new SugarDecorator(c); // 继续叠加装饰

Java IO 体系大量使用装饰器模式：BufferedInputStream(new FileInputStream(...))

适配器模式

让不兼容的接口协同工作。

// 目标接口
public interface JsonParser {
    Object parse(String json);
}
 
// 被适配者（已有类，接口不匹配）
public class XmlParser {
    public Object parseXml(String xml) { ... }
}
 
// 适配器
public class XmlToJsonAdapter implements JsonParser {
    private final XmlParser xmlParser;
 
    public XmlToJsonAdapter(XmlParser xmlParser) {
        this.xmlParser = xmlParser;
    }
 
    @Override
    public Object parse(String json) {
        String xml = jsonToXml(json);
        return xmlParser.parseXml(xml);
    }
}

外观模式

为子系统提供简化的统一接口。

public class OrderFacade {
    private final InventoryService inventory;
    private final PaymentService payment;
    private final NotificationService notification;
 
    public void placeOrder(Order order) {
        inventory.reserve(order);
        payment.charge(order);
        notification.sendConfirmation(order);
    }
}

组合模式

将对象组合成树形结构，统一处理单个对象和组合。

public interface FileSystemNode {
    void print(String indent);
    long getSize();
}
 
public class File implements FileSystemNode {
    private String name;
    private long size;
    public void print(String indent) { System.out.println(indent + name); }
    public long getSize() { return size; }
}
 
public class Directory implements FileSystemNode {
    private String name;
    private List<FileSystemNode> children = new ArrayList<>();
 
    public void add(FileSystemNode node) { children.add(node); }
 
    public void print(String indent) {
        System.out.println(indent + name + "/");
        children.forEach(c -> c.print(indent + "  "));
    }
 
    public long getSize() {
        return children.stream().mapToLong(FileSystemNode::getSize).sum();
    }
}

行为型

观察者模式

定义对象间一对多依赖，一个对象状态改变时通知所有依赖者。

public interface Observer {
    void update(Event event);
}
 
public class EventBus {
    private final Map<String, List<Observer>> listeners = new HashMap<>();
 
    public void subscribe(String eventType, Observer observer) {
        listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(observer);
    }
 
    public void publish(String eventType, Event event) {
        listeners.getOrDefault(eventType, List.of())
                 .forEach(o -> o.update(event));
    }
}

策略模式

定义算法族，使它们可以互相替换。

public interface SortStrategy {
    void sort(int[] arr);
}
 
public class Sorter {
    private SortStrategy strategy;
 
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
 
    public void sort(int[] arr) {
        strategy.sort(arr);
    }
}
 
// 使用
Sorter sorter = new Sorter();
sorter.setStrategy(new QuickSort());
sorter.sort(data);
sorter.setStrategy(new MergeSort());
sorter.sort(data);
 
// Lambda 简化
sorter.setStrategy(arr -> Arrays.sort(arr));

模板方法模式

父类定义算法骨架，子类实现具体步骤。

public abstract class DataProcessor {
    // 模板方法
    public final void process() {
        readData();
        processData();
        writeData();
    }
 
    protected abstract void readData();
    protected abstract void processData();
 
    protected void writeData() {  // 可选重写的默认实现
        System.out.println("写出数据");
    }
}
 
public class CsvProcessor extends DataProcessor {
    protected void readData() { /* 读 CSV */ }
    protected void processData() { /* 处理 CSV */ }
}

责任链模式

将请求沿处理者链传递，直到有人处理。

public abstract class Handler {
    protected Handler next;
 
    public Handler setNext(Handler next) {
        this.next = next;
        return next; // 支持链式设置
    }
 
    public abstract void handle(Request request);
}
 
public class AuthHandler extends Handler {
    public void handle(Request request) {
        if (!request.isAuthenticated()) {
            throw new UnauthorizedException();
        }
        if (next != null) next.handle(request);
    }
}
 
// 构建责任链
Handler chain = new AuthHandler();
chain.setNext(new RateLimitHandler())
     .setNext(new LogHandler())
     .setNext(new BusinessHandler());
 
chain.handle(request);

命令模式

将请求封装为对象，支持撤销、队列、日志。

public interface Command {
    void execute();
    void undo();
}
 
public class TextEditor {
    private StringBuilder text = new StringBuilder();
    private Deque<Command> history = new ArrayDeque<>();
 
    public void executeCommand(Command cmd) {
        cmd.execute();
        history.push(cmd);
    }
 
    public void undo() {
        if (!history.isEmpty()) history.pop().undo();
    }
}

设计原则（SOLID）

原则说明
S 单一职责一个类只有一个改变的理由
O 开闭原则对扩展开放，对修改关闭
L 里氏替换子类可以替换父类而不破坏程序
I 接口隔离不强迫依赖不使用的接口
D 依赖倒置依赖抽象，不依赖具体实现

相关链接

关系图谱

反向链接