设计模式在项目中的应用

能力考察点

这个问题主要考察：

• 面试者对设计模式的理解和掌握程度
• 面试者的实际项目经验
• 面试者分析问题和解决问题的能力
• 面试者的技术表达能力和逻辑思维能力

答题思路

1. 首先简要说明设计模式的概念和重要性
2. 列举自己在项目中使用过的几种主要设计模式（选择3-5种最熟悉、最有代表性的）
3. 对每种设计模式：
   • 简要介绍其定义和核心思想
   • 详细说明在项目中的具体应用场景
   • 解释为什么选择这种设计模式，它解决了什么问题
   • 可以提供简化的代码示例或架构图示
4. 总结使用设计模式带来的好处和经验教训

答题示例

大家好，我是小明，一名计算机专业的应届毕业生。在校期间，我参与了多个项目开发，并在其中应用了多种设计模式来解决实际问题。下面我将分享我在项目中使用过的几种设计模式及其应用场景。

1. 单例模式（Singleton Pattern）

定义与核心思想： 单例模式确保一个类只有一个实例，并提供一个全局访问点。它主要用于那些只需要一个实例就能协调系统整体行为的场景。

应用场景： 在我开发的校园二手交易平台中，我使用单例模式实现了数据库连接池和配置管理器。

代码示例：

public class DatabaseConnectionPool {
    private static volatile DatabaseConnectionPool instance;
    private List<Connection> connections;
    
    // 私有构造函数
    private DatabaseConnectionPool() {
        // 初始化连接池
        connections = new ArrayList<>();
        // 创建初始连接
        for (int i = 0; i < 10; i++) {
            connections.add(createNewConnection());
        }
    }
    
    // 双重检查锁定获取单例
    public static DatabaseConnectionPool getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionPool();
                }
            }
        }
        return instance;
    }
    
    public Connection getConnection() {
        // 获取连接的逻辑
    }
    
    public void releaseConnection(Connection connection) {
        // 释放连接的逻辑
    }
}

解决的问题：

• 避免了创建多个数据库连接池造成的资源浪费
• 确保配置信息在整个应用中保持一致
• 提供了一个全局访问点，方便其他模块使用

2. 工厂模式（Factory Pattern）

定义与核心思想： 工厂模式提供了一个创建对象的接口，但让子类决定实例化哪一个类。它使一个类的实例化延迟到其子类。

应用场景： 在校园二手交易平台中，我使用工厂模式来创建不同类型的支付处理器。

代码示例：

// 支付处理器接口
public interface PaymentProcessor {
    boolean processPayment(Order order);
}

// 支付宝支付处理器
public class AlipayProcessor implements PaymentProcessor {
    public boolean processPayment(Order order) {
        // 支付宝支付逻辑
        return true;
    }
}

// 微信支付处理器
public class WechatPayProcessor implements PaymentProcessor {
    public boolean processPayment(Order order) {
        // 微信支付逻辑
        return true;
    }
}

// 支付处理器工厂
public class PaymentProcessorFactory {
    public static PaymentProcessor createProcessor(String paymentType) {
        switch (paymentType) {
            case "ALIPAY":
                return new AlipayProcessor();
            case "WECHAT":
                return new WechatPayProcessor();
            default:
                throw new IllegalArgumentException("Unsupported payment type: " + paymentType);
        }
    }
}

解决的问题：

• 解耦了支付逻辑的创建和使用
• 便于扩展新的支付方式，符合开闭原则
• 代码更加清晰，职责划分明确

3. 观察者模式（Observer Pattern）

定义与核心思想： 观察者模式定义了对象之间一对多的依赖关系，当一个对象状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

应用场景： 在校园二手交易平台中，我使用观察者模式实现了商品状态变更通知系统。

代码示例：

// 观察者接口
public interface Observer {
    void update(Product product);
}

// 具体观察者：收藏用户
public class FavoriteUser implements Observer {
    private String userId;
    
    public FavoriteUser(String userId) {
        this.userId = userId;
    }
    
    @Override
    public void update(Product product) {
        // 发送通知给收藏该商品的用户
        NotificationService.sendNotification(userId, 
            "您收藏的商品 " + product.getName() + " 状态已更新为: " + product.getStatus());
    }
}

// 被观察者：商品
public class Product {
    private List<Observer> observers = new ArrayList<>();
    private String status;
    private String name;
    
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    
    public void setStatus(String status) {
        this.status = status;
        notifyObservers();
    }
    
    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
    // 其他getter和setter方法
}

解决的问题：

• 实现了商品状态变更与用户通知的解耦
• 支持动态添加和移除观察者
• 便于扩展新的通知方式

4. 策略模式（Strategy Pattern）

定义与核心思想： 策略模式定义了一系列算法，将每个算法封装起来，并使它们可以互相替换。策略模式让算法独立于使用它的客户端而变化。

应用场景： 在校园二手交易平台中，我使用策略模式实现了不同的商品排序策略。

代码示例：

// 排序策略接口
public interface SortStrategy {
    List<Product> sort(List<Product> products);
}

// 按价格排序策略
public class PriceSortStrategy implements SortStrategy {
    private boolean ascending;
    
    public PriceSortStrategy(boolean ascending) {
        this.ascending = ascending;
    }
    
    @Override
    public List<Product> sort(List<Product> products) {
        return products.stream()
            .sorted(ascending ? 
                Comparator.comparing(Product::getPrice) : 
                Comparator.comparing(Product::getPrice).reversed())
            .collect(Collectors.toList());
    }
}

// 按发布时间排序策略
public class TimeSortStrategy implements SortStrategy {
    private boolean ascending;
    
    public TimeSortStrategy(boolean ascending) {
        this.ascending = ascending;
    }
    
    @Override
    public List<Product> sort(List<Product> products) {
        return products.stream()
            .sorted(ascending ? 
                Comparator.comparing(Product::getPublishTime) : 
                Comparator.comparing(Product::getPublishTime).reversed())
            .collect(Collectors.toList());
    }
}

// 上下文类
public class ProductSorter {
    private SortStrategy strategy;
    
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    public List<Product> sortProducts(List<Product> products) {
        if (strategy == null) {
            throw new IllegalStateException("Sort strategy not set");
        }
        return strategy.sort(products);
    }
}

解决的问题：

• 避免了使用多重条件语句导致的代码臃肿
• 便于扩展新的排序算法
• 算法可以自由切换，提高了灵活性

5. 适配器模式（Adapter Pattern）

定义与核心思想： 适配器模式将一个类的接口转换成客户端期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

应用场景： 在校园二手交易平台中，我使用适配器模式整合了第三方物流查询接口。

代码示例：

// 目标接口
public interface LogisticsTracker {
    TrackingInfo track(String orderId);
}

// 第三方物流服务A
public class LogisticsServiceA {
    public LogisticsResult queryLogistics(String logisticsNumber) {
        // 查询物流信息
        return new LogisticsResult();
    }
}

// 适配器
public class LogisticsServiceAAdapter implements LogisticsTracker {
    private LogisticsServiceA serviceA;
    
    public LogisticsServiceAAdapter(LogisticsServiceA serviceA) {
        this.serviceA = serviceA;
    }
    
    @Override
    public TrackingInfo track(String orderId) {
        // 调用第三方服务A的API
        LogisticsResult result = serviceA.queryLogistics(orderId);
        
        // 转换结果
        TrackingInfo info = new TrackingInfo();
        info.setStatus(result.getStatus());
        info.setUpdateTime(result.getTime());
        // 其他转换逻辑...
        
        return info;
    }
}

// 使用适配器的客户端
public class OrderTrackingService {
    private LogisticsTracker tracker;
    
    public OrderTrackingService(LogisticsTracker tracker) {
        this.tracker = tracker;
    }
    
    public TrackingInfo trackOrder(String orderId) {
        return tracker.track(orderId);
    }
}

解决的问题：

• 使不兼容的接口能够协同工作
• 无需修改原有代码，提高了代码的复用性
• 便于替换不同的第三方服务实现

设计模式之间的关系

下面是我在项目中使用的几种设计模式之间的关系图：

总结

通过在项目中应用这些设计模式，我获得了以下经验和收获：

1. 提高代码复用性：设计模式使代码更加模块化，提高了代码的复用性。
2. 增强代码可维护性：良好的设计使代码结构清晰，便于后续维护和扩展。
3. 降低系统耦合度：通过依赖倒置、接口隔离等原则，降低了系统各模块之间的耦合度。
4. 提高开发效率：面对常见问题时，可以直接应用成熟的设计模式解决方案，减少重复思考时间。
5. 促进团队协作：设计模式是通用的设计语言，使用设计模式有助于团队成员之间的沟通和理解。

在实际开发中，我认为选择合适的设计模式需要考虑以下几点：

• 问题的本质和需求
• 团队成员的技术水平和熟悉程度
• 项目的复杂度和规模
• 未来的扩展需求

设计模式不是银弹，不应为了使用模式而使用模式，而应根据实际需求选择合适的解决方案。在未来的工作中，我将继续学习和应用设计模式，不断提高自己的设计能力和代码质量。

参考资料

1. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
2. Martin, R. C. (2017). Clean Architecture: A Craftsman's Guide to Software Structure and Design. Prentice Hall.
3. Freeman, E., Robson, E., Bates, B., & Sierra, K. (2004). Head First Design Patterns. O'Reilly Media.
4. Refactoring.Guru - Design Patterns
5. Java Design Patterns - JournalDev