当前位置：首页 > news >正文

Java八股文实践篇：从理论到DeOldify项目中的设计模式应用

news 2026/5/28 20:42:16

Java八股文实践篇：从理论到DeOldify项目中的设计模式应用

每次面试被问到设计模式，是不是都只能背出“单例模式确保一个类只有一个实例”这样的标准答案？背得滚瓜烂熟，但一上手写代码，还是觉得这些模式离自己很远，不知道怎么用。

其实，设计模式从来不是用来背诵的“八股文”，而是解决实际工程问题的工具箱。今天，我们不谈抽象理论，直接看一个具体的项目——DeOldify图像上色项目。我会带你看看，在这个真实的AI应用里，如何把面试常考的那些设计模式，像搭积木一样用起来，让代码变得更清晰、更好维护。

你会发现，原来工厂模式可以帮你灵活切换不同的图片预处理策略，观察者模式能让任务进度更新变得优雅，而代理模式则是管理复杂AI模型调用的好帮手。我们边看代码边聊，保证你能看懂，还能直接用到自己的项目里。

1. 项目背景：当老照片遇见设计模式

DeOldify是一个基于深度学习的开源项目，它能让黑白老照片恢复色彩，效果非常惊艳。但今天我们不深入它的AI模型，而是聚焦在如何用Java构建一个健壮、易扩展的应用来集成这个能力。

想象一下，你要开发一个老照片上色服务。用户上传照片，你调用DeOldify模型处理，然后返回彩色结果。这个流程听起来简单，但仔细一想，问题就来了：

图片可能有不同格式（JPG、PNG）和大小，需要不同的预处理。
上色是个耗时操作，用户想知道进度。
直接调用模型服务可能不稳定，需要重试、降级或缓存。
未来如果想换一个上色模型，或者增加新的功能（如修复划痕），代码会不会改得面目全非？

这就是设计模式大显身手的地方。它们不是来增加复杂度的，而是来帮你管理复杂度，让代码在面对变化时更从容。下面，我们就进入正题，看看几个核心模式是怎么落地的。

2. 工厂模式：灵活创建图片处理策略

面试官常问：“说说工厂模式的好处？” 标准答案是解耦。在DeOldify项目里，这个“耦”体现在哪呢？就在图片预处理这个环节。

用户上传的图片千差万别。有的需要先缩放到模型接受的尺寸，有的需要从PNG转换成JPG，有的甚至需要先进行简单的降噪。如果我们把这些处理逻辑都写在一个巨大的if-else里，代码很快就会变成一锅粥。

这时，工厂模式就派上用场了。它的核心思想是：定义一个创建对象的接口，但让子类决定实例化哪一个类。

2.1 策略接口与具体实现

首先，我们定义一个所有预处理策略都要遵守的契约。

// 图像预处理策略接口 public interface ImagePreprocessStrategy { /** * 处理原始图像 * @param originalImage 原始图像数据 * @return 处理后的图像数据 */ BufferedImage process(BufferedImage originalImage); }

接着，实现几种具体的策略：

// 策略一：简单缩放 public class ResizeStrategy implements ImagePreprocessStrategy { private int targetWidth; private int targetHeight; public ResizeStrategy(int width, int height) { this.targetWidth = width; this.targetHeight = height; } @Override public BufferedImage process(BufferedImage originalImage) { // 实现缩放逻辑 Image scaledImage = originalImage.getScaledInstance(targetWidth, targetHeight, Image.SCALE_SMOOTH); BufferedImage outputImage = new BufferedImage(targetWidth, targetHeight, originalImage.getType()); outputImage.getGraphics().drawImage(scaledImage, 0, 0, null); System.out.println("执行了缩放预处理"); return outputImage; } } // 策略二：格式转换（例如转RGB） public class ConvertToRGBStrategy implements ImagePreprocessStrategy { @Override public BufferedImage process(BufferedImage originalImage) { if (originalImage.getType() == BufferedImage.TYPE_INT_RGB) { return originalImage; } BufferedImage rgbImage = new BufferedImage( originalImage.getWidth(), originalImage.getHeight(), BufferedImage.TYPE_INT_RGB ); rgbImage.getGraphics().drawImage(originalImage, 0, 0, null); System.out.println("执行了RGB格式转换预处理"); return rgbImage; } }

2.2 工厂类登场

现在，我们需要一个地方来决定，对于某张图片，到底该用哪种策略。这就是工厂。

// 预处理策略工厂 public class PreprocessStrategyFactory { public static ImagePreprocessStrategy createStrategy(String imageType, int fileSizeKB) { // 这里是业务逻辑：根据图片特征选择策略 if (fileSizeKB > 1024) { // 文件大于1MB，先缩放 return new ResizeStrategy(512, 512); } else if (!imageType.equalsIgnoreCase("jpg")) { // 非JPG格式，统一转RGB，确保模型输入一致 return new ConvertToRGBStrategy(); } else { // 默认情况，也可能是一个“什么都不做”的空策略 return original -> { System.out.println("使用默认预处理（无操作）"); return original; }; } } }

2.3 在服务中使用工厂

最后，在我们的上色服务里，使用方式变得非常清晰：

public class DeOldifyService { public BufferedImage colorizeImage(BufferedImage originalImage, String imageType, int fileSize) { // 1. 使用工厂获取预处理策略 ImagePreprocessStrategy strategy = PreprocessStrategyFactory.createStrategy(imageType, fileSize); // 2. 执行预处理 BufferedImage processedImage = strategy.process(originalImage); // 3. 调用DeOldify模型核心上色逻辑（这里用伪代码表示） // BufferedImage coloredImage = deOldifyModel.colorize(processedImage); System.out.println("调用DeOldify模型进行上色..."); BufferedImage coloredImage = processedImage; // 假设上色完成 return coloredImage; } }

这样做的好处是什么？如果明天我们需要增加一个“人脸区域增强”的预处理策略，只需要新建一个FaceEnhanceStrategy类实现接口，然后在工厂的创建逻辑里加上新的判断条件即可。DeOldifyService的代码一行都不用改。这就是对修改关闭，对扩展开放的开闭原则，也是工厂模式带来的核心价值。

3. 观察者模式：优雅的通知任务进度

上色一张高分辨率老照片可能需要几秒甚至十几秒。用户在前端等着，一个空白的进度条体验极差。我们需要一种机制，当上色任务的状态发生变化（开始、进度更新、完成、失败）时，能主动通知所有关心它的部分。

这就是观察者模式的典型场景。它的定义是：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

3.1 定义观察者与主题

我们先定义谁是被观察的（主题），以及谁是观察者。

// 观察者接口：所有关心任务进度的对象都需要实现这个接口 public interface TaskProgressObserver { void update(TaskProgressEvent event); } // 任务进度事件：封装状态信息 public class TaskProgressEvent { private String taskId; private String status; // “STARTED”, “PROCESSING”, “COMPLETED”, “FAILED” private int progress; // 0-100 private String message; // 构造方法、getter、setter 省略... }

被观察的主题，就是我们的上色任务。

// 被观察的主题：上色任务 public class ColorizationTask { private String taskId; private List<TaskProgressObserver> observers = new ArrayList<>(); // 注册观察者 public void addObserver(TaskProgressObserver observer) { observers.add(observer); } // 移除观察者 public void removeObserver(TaskProgressObserver observer) { observers.remove(observer); } // 通知所有观察者 private void notifyObservers(TaskProgressEvent event) { for (TaskProgressObserver observer : observers) { observer.update(event); } } // 核心执行方法 public void execute() { TaskProgressEvent startEvent = new TaskProgressEvent(taskId, "STARTED", 0, "任务开始"); notifyObservers(startEvent); try { // 模拟处理过程 for (int i = 1; i <= 10; i++) { Thread.sleep(300); // 模拟耗时 TaskProgressEvent progressEvent = new TaskProgressEvent(taskId, "PROCESSING", i * 10, "处理中..."); notifyObservers(progressEvent); } TaskProgressEvent completeEvent = new TaskProgressEvent(taskId, "COMPLETED", 100, "上色完成"); notifyObservers(completeEvent); } catch (InterruptedException e) { TaskProgressEvent failEvent = new TaskProgressEvent(taskId, "FAILED", 0, "任务被中断"); notifyObservers(failEvent); } } }

3.2 实现具体的观察者

谁会是观察者呢？可能是数据库（记录日志）、消息队列（通知前端）、或者监控系统。

// 观察者一：数据库日志记录器 public class DatabaseLogger implements TaskProgressObserver { @Override public void update(TaskProgressEvent event) { // 将任务事件记录到数据库 System.out.println("[数据库日志] 任务 " + event.getTaskId() + " 状态: " + event.getStatus() + ", 进度: " + event.getProgress() + "%"); } } // 观察者二：WebSocket推送器（通知前端） public class WebSocketNotifier implements TaskProgressObserver { @Override public void update(TaskProgressEvent event) { // 通过WebSocket将进度推送给前端浏览器 System.out.println("[WebSocket推送] 向客户端推送任务进度: " + event.getProgress() + "%"); } }

3.3 组装与运行

现在，我们把它们组装起来：

public class TaskDemo { public static void main(String[] args) { ColorizationTask task = new ColorizationTask("TASK_001"); // 注册观察者 task.addObserver(new DatabaseLogger()); task.addObserver(new WebSocketNotifier()); // 执行任务，观察者会自动被通知 task.execute(); } }

运行后，你会看到数据库和WebSocket都收到了同步的状态更新。最大的好处是解耦：ColorizationTask完全不知道也不关心是谁在监听它，它只负责发出通知。未来要加一个短信通知，只需要新建一个SmsNotifier并注册进去就行，任务本身的代码纹丝不动。

4. 代理模式：为DeOldify服务加上“安全气囊”

直接调用一个外部的、耗时的、可能不稳定的AI模型服务是危险的。网络可能抖动，模型可能崩溃，响应可能超时。我们需要一个“替身”来替我们管理这些风险，这个替身就是代理模式。

代理模式：为其他对象提供一种代理以控制对这个对象的访问。在我们的场景里，这个“其他对象”就是真正的DeOldify模型调用。

4.1 定义共同接口

首先，定义上色服务的接口，这是真实对象和代理对象都要实现的。

// 上色服务接口 public interface ColorizationService { BufferedImage colorize(BufferedImage image) throws ServiceException; }

4.2 真实对象：直接调用模型

// 真实对象：直接调用DeOldify（可能是HTTP请求或本地库调用） public class DeOldifyServiceImpl implements ColorizationService { @Override public BufferedImage colorize(BufferedImage image) throws ServiceException { System.out.println("真实调用DeOldify模型API..."); // 这里是一个模拟的、不稳定的调用 if (Math.random() > 0.7) { // 30%概率模拟失败 throw new ServiceException("DeOldify服务调用超时"); } // 模拟处理耗时 try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return image; // 假设返回上色后的图片 } }

4.3 代理对象：增强功能

代理对象也实现同样的接口，但它内部持有一个真实对象的引用，并在调用前后添加额外逻辑。

// 代理对象：增强的DeOldify服务 public class DeOldifyServiceProxy implements ColorizationService { private ColorizationService realService; private Cache<String, BufferedImage> cache; // 引入缓存 private int retryTimes = 3; public DeOldifyServiceProxy() { this.realService = new DeOldifyServiceImpl(); this.cache = CacheBuilder.newBuilder() .maximumSize(100) .expireAfterWrite(10, TimeUnit.MINUTES) .build(); } @Override public BufferedImage colorize(BufferedImage image) throws ServiceException { // 1. 缓存逻辑 String imageKey = generateImageKey(image); BufferedImage cachedResult = cache.getIfPresent(imageKey); if (cachedResult != null) { System.out.println("缓存命中，直接返回结果"); return cachedResult; } // 2. 重试与降级逻辑 ServiceException lastException = null; for (int i = 0; i < retryTimes; i++) { try { System.out.println("第 " + (i + 1) + " 次尝试调用..."); BufferedImage result = realService.colorize(image); // 3. 调用成功，存入缓存 cache.put(imageKey, result); return result; } catch (ServiceException e) { lastException = e; System.out.println("调用失败，准备重试"); } } // 4. 所有重试都失败，执行降级策略 System.out.println("所有重试失败，启用降级方案：返回原图"); // 这里可以返回一个默认图，或者进行简单的图像处理作为降级 return image; } private String generateImageKey(BufferedImage image) { // 生成一个基于图片内容的简单键，这里用哈希码模拟 return "IMG_" + image.hashCode(); } }

4.4 客户端使用代理

对于调用方（客户端）来说，它根本感知不到代理的存在，因为它使用的是同样的接口。

public class Client { public static void main(String[] args) { // 客户端直接使用代理，无需知道背后的复杂逻辑 ColorizationService service = new DeOldifyServiceProxy(); try { BufferedImage inputImage = ImageIO.read(new File("old_photo.jpg")); BufferedImage outputImage = service.colorize(inputImage); System.out.println("上色完成"); } catch (Exception e) { e.printStackTrace(); } } }

通过代理模式，我们无侵入地给核心服务加上了缓存、重试、降级这三重“安全气囊”。如果未来要增加限流、熔断或者日志审计，也只需要修改代理类，真实的核心业务逻辑DeOldifyServiceImpl依然保持纯净。