如何在Spring Boot中使用Java设计模式 – 通过代码示例解释

随着软件项目的发展，保持代码的组织性、可维护性和可扩展性变得越来越重要。这就是设计模式发挥作用的地方。设计模式提供了针对常见软件设计挑战的经过验证的可重复使用解决方案，使您的代码更高效、更易管理。

在本指南中，我们将深入探讨一些最流行的设计模式，并向您展示如何在Spring Boot中实现它们。最终，您不仅将在概念上理解这些模式，还能够自信地将它们应用到您自己的项目中。

目录

• 设计模式简介

• 如何设置Spring Boot项目

• 单例模式是什么？

• 工厂模式是什么？

• 什么是策略模式？

• 什么是观察者模式？

• 如何使用Spring Boot的依赖注入

• 最佳实践和优化技巧

• 总结和关键要点

设计模式简介

设计模式是常见软件设计问题的可重用解决方案。可以将它们视为融合成模板的最佳实践，可应用于解决代码中特定挑战。它们不针对任何特定语言，但由于Java具有面向对象的特性，它们在Java中可能特别强大。

在本指南中，我们将涵盖：

• 单例模式：确保一个类只有一个实例。

• 工厂模式：创建对象时不指定确切的类。

• 策略模式：允许在运行时选择算法。

• 观察者模式：建立发布-订阅关系。

我们不仅会介绍这些模式的工作原理，还会探讨它们如何应用于Spring Boot的实际应用程序中。

如何设置Spring Boot项目

在深入讨论这些模式之前，让我们先建立一个Spring Boot项目：

先决条件

确保您有：

• Java 11+

• Maven

• Spring Boot CLI（可选）

• Postman或curl（用于测试）

项目初始化

您可以使用Spring Initializr快速创建Spring Boot项目：

curl https://start.spring.io/starter.zip \
-d dependencies=web \
-d name=DesignPatternsDemo \
-d javaVersion=11 -o design-patterns-demo.zip
unzip design-patterns-demo.zip
cd design-patterns-demo

单例模式是什么？

单例模式确保一个类只有一个实例，并提供一个全局访问点。该模式通常用于日志记录、配置管理或数据库连接等服务。

如何在Spring Boot中实现单例模式

Spring Boot的bean默认是单例的，这意味着Spring会自动管理这些bean的生命周期，以确保只存在一个实例。但是，重要的是要了解单例模式的工作原理，特别是当您不使用Spring管理的bean或需要更多对实例管理的控制时。

让我们通过手动实现单例模式来演示如何控制应用程序中单个实例的创建。

步骤1：创建LoggerService类

在这个例子中，我们将使用单例模式创建一个简单的日志记录服务。目标是确保应用程序的所有部分都使用相同的日志记录实例。

public class LoggerService {
    // 用于保存单例实例的静态变量
    private static LoggerService instance;

    // 私有构造函数，防止外部实例化
    private LoggerService() {
        // 这个构造函数故意为空，以防止其他类创建实例
    }

    // 公共方法提供对单例实例的访问
    public static synchronized LoggerService getInstance() {
        if (instance == null) {
            instance = new LoggerService();
        }
        return instance;
    }

    // 示例日志方法
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

• 静态变量（instance）：这个变量保存了LoggerService的单例实例。

• 私有构造函数：构造函数被标记为私有，以防止其他类直接创建新实例。

• 同步的 getInstance() 方法：该方法被同步化，使其线程安全，确保即使多个线程尝试同时访问，也只创建一个实例。

• 延迟初始化: 只有在首次请求时才创建实例（延迟初始化），在内存使用方面效率较高。

实际应用: 这种模式通常用于共享资源，例如日志记录、配置设置或管理数据库连接，您希望控制访问并确保在整个应用程序中只使用一个实例。

步骤 2：在 Spring Boot 控制器中使用单例

现在，让我们看看如何在 Spring Boot 控制器中使用我们的 LoggerService 单例。这个控制器将暴露一个端点，每当访问时都会记录一条消息。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LogController {

    @GetMapping("/log")
    public ResponseEntity<String> logMessage() {
        // 访问 LoggerService 的单例实例
        LoggerService logger = LoggerService.getInstance();
        logger.log("This is a log message!");
        return ResponseEntity.ok("Message logged successfully");
    }
}

• GET 端点: 我们创建了一个 /log 端点，当访问时，会使用 LoggerService 记录一条消息。

• 单例使用: 我们不再创建 LoggerService 的新实例，而是调用 getInstance() 以确保每次使用相同的实例。

• 响应：在记录日志后，端点返回一个表示成功的响应。

步骤3：测试单例模式

现在，让我们使用Postman或您的浏览器来测试这个端点：

GET http://localhost:8080/log

预期输出：

• 控制台日志：[LOG] 这是一个日志消息！

• HTTP响应：消息成功记录

您可以多次调用端点，您会看到每次使用的都是相同的LoggerService实例，这可以通过一致的日志输出来说明。

单例模式在实际应用中的使用场景

以下是在实际应用中可能需要使用单例模式的情况：

1. 配置管理：确保您的应用程序使用一致的配置设置，特别是当这些设置从文件或数据库中加载时。

2. 数据库连接池: 控制对有限数量的数据库连接的访问，确保应用程序中共享同一个连接池。

3. 缓存: 维护一个单一的缓存实例，以避免数据不一致。

4. 日志服务: 如本示例所示，使用单一的日志服务来集中不同模块的日志输出。

要点

• 单例模式是确保类只创建一个实例的简单方法。

• 如果多个线程访问单例，则线程安全至关重要，这就是为什么我们在示例中使用了synchronized。

• Spring Boot中的bean默认已经是单例，但了解如何手动实现有助于在需要时获得更多控制。

这涵盖了单例模式的实现和用法。接下来，我们将探讨工厂模式，看看它如何帮助简化对象创建。

什么是工厂模式？

工厂模式允许您创建对象而无需指定确切的类。这种模式在您需要根据某些输入实例化不同类型的对象时非常有用。

如何在Spring Boot中实现工厂模式

当您需要根据特定标准创建对象但希望将对象创建过程与主应用程序逻辑解耦时，工厂模式非常有用。

在本节中，我们将介绍构建一个NotificationFactory以通过电子邮件或短信发送通知。如果您预计将来添加更多通知类型，例如推送通知或应用内警报，而不更改现有代码，则这将非常有用。

步骤1：创建Notification接口

第一步是定义所有通知类型都将实现的通用接口。这确保每种类型的通知（电子邮件、短信等）都具有一致的send()方法。

public interface Notification {
    void send(String message);
}

• 目的： Notification接口定义了发送通知的约定。实现此接口的任何类都必须为send()方法提供实现。

• 可扩展性: 通过使用接口，您可以轻松地在未来扩展您的应用程序，包括其他类型的通知，而无需修改现有代码。

步骤2: 实现 EmailNotification 和 SMSNotification

现在，让我们实现两个具体类，一个用于发送电子邮件，另一个用于发送短信。

public class EmailNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("Sending Email: " + message);
    }
}

public class SMSNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

步骤3: 创建一个 NotificationFactory

NotificationFactory 类负责根据指定的类型创建 Notification 实例。这种设计确保 NotificationController 不需要了解对象创建的细节。

public class NotificationFactory {
    public static Notification createNotification(String type) {
        switch (type.toUpperCase()) {
            case "EMAIL":
                return new EmailNotification();
            case "SMS":
                return new SMSNotification();
            default:
                throw new IllegalArgumentException("Unknown notification type: " + type);
        }
    }
}

工厂方法 (createNotification()):

• 工厂方法以字符串 (type) 作为输入，并返回相应通知类的实例。

• Switch 语句: switch 语句根据输入选择适当的通知类型。

• 错误处理: 如果提供的类型未被识别，它会抛出一个IllegalArgumentException。这确保了无效类型能被早期捕获。

为什么使用工厂模式？

• 解耦: 工厂模式将对象的创建与业务逻辑解耦。这使得您的代码更具模块化且更易于维护。

• 可扩展性: 如果您想要添加新的通知类型，您只需要更新工厂而无需更改控制器逻辑。

第四步：在Spring Boot控制器中使用工厂

现在，让我们把一切整合起来，创建一个Spring Boot控制器，该控制器使用NotificationFactory根据用户请求发送通知。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class NotificationController {

    @GetMapping("/notify")
    public ResponseEntity<String> notify(@RequestParam String type, @RequestParam String message) {
        try {
            // 使用工厂创建适当的Notification对象
            Notification notification = NotificationFactory.createNotification(type);
            notification.send(message);
            return ResponseEntity.ok("Notification sent successfully!");
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }
}

GET端点（/notify）:

• 控制器公开一个/notify端点，接受两个查询参数：type（”EMAIL”或”SMS”）和message。

• 它使用NotificationFactory创建适当的通知类型并发送消息。

• 错误处理：如果提供了无效的通知类型，则控制器捕获IllegalArgumentException并返回400 Bad Request响应。

第5步：测试工厂模式

让我们使用Postman或浏览器测试端点：

1. 发送电子邮件通知：

    GET http://localhost:8080/notify?type=email&message=Hello%20Email
   

   输出：

    发送电子邮件：Hello Email
   

2. 发送短信通知:

    GET http://localhost:8080/notify?type=sms&message=Hello%20SMS
   

   输出:

    发送短信: Hello SMS
   

3. 测试无效类型:

    GET http://localhost:8080/notify?type=unknown&message=Test
   

   输出:

    错误请求: 未知通知类型: unknown
   

工厂模式的真实应用场景

工厂模式在以下情况特别有用：

1. 动态对象创建: 当您需要根据用户输入创建对象时，例如发送不同类型的通知、生成不同格式的报告或处理不同的支付方法。

2. 解耦对象创建：通过使用工厂，您可以将主要业务逻辑与对象创建分开，使您的代码更易于维护。

3. 可扩展性：轻松扩展应用程序以支持新类型的通知，而无需修改现有代码。只需添加一个实现Notification接口的新类并更新工厂。

什么是策略模式？

策略模式非常适用于需要在多个算法或行为之间动态切换的情况。它允许您定义一组算法，将每个算法封装在单独的类中，并在运行时轻松互换它们。这对基于特定条件选择算法非常有用，使您的代码清晰、模块化和灵活。

实际应用案例：想象一个需要支持多种支付选项（如信用卡、PayPal 或银行转账）的电子商务系统。通过使用策略模式，您可以轻松添加或修改支付方法，而不需要改动现有代码。这种方法确保您的应用在引入新功能或更新现有功能时仍然具有可伸缩性和可维护性。

我们将通过一个使用 Spring Boot 处理信用卡或 PayPal 策略的支付示例来演示这种模式。

第 1 步：定义一个 PaymentStrategy 接口

我们首先创建一个所有支付策略都将实现的通用接口：

public interface PaymentStrategy {
    void pay(double amount);
}

该接口为所有支付方法定义了一个契约，确保实现的一致性。

第 2 步：实现支付策略

创建信用卡和 PayPal 支付的具体类。

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " with Credit Card");
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " via PayPal");
    }
}

每个类都使用其特定行为实现 pay() 方法。

第 3 步：在控制器中使用策略

创建一个控制器根据用户输入动态选择支付策略：

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PaymentController {

    @GetMapping("/pay")
    public ResponseEntity<String> processPayment(@RequestParam String method, @RequestParam double amount) {
        PaymentStrategy strategy = selectPaymentStrategy(method);
        if (strategy == null) {
            return ResponseEntity.badRequest().body("Invalid payment method");
        }
        strategy.pay(amount);
        return ResponseEntity.ok("Payment processed successfully!");
    }

    private PaymentStrategy selectPaymentStrategy(String method) {
        switch (method.toUpperCase()) {
            case "CREDIT": return new CreditCardPayment();
            case "PAYPAL": return new PayPalPayment();
            default: return null;
        }
    }
}

该端点接受 method 和 amount 作为查询参数，并使用适当的策略处理支付。

第 4 步：测试端点

1. 信用卡支付:

    GET http://localhost:8080/pay?method=credit&amount=100
   

   输出: 使用信用卡支付 $100.0

2. PayPal支付:

    GET http://localhost:8080/pay?method=paypal&amount=50
   

   输出: 通过PayPal支付 $50.0

3. 无效支付方式:

    GET http://localhost:8080/pay?method=bitcoin&amount=25
   

   输出: 无效支付方式

策略模式的用例

• 支付处理：动态切换不同的支付网关。

• 排序算法：根据数据大小选择最佳排序方法。

• 文件导出：以各种格式（PDF、Excel、CSV）导出报告。

要点

• 策略模式使您的代码模块化，并遵循开闭原则。

• 添加新策略很容易—只需创建一个实现PaymentStrategy接口的新类。

• 它非常适用于需要在运行时灵活选择算法的场景。

接下来，我们将探讨观察者模式，非常适合处理基于事件的架构。

什么是观察者模式？

观察者模式在您有一个对象（主题）需要通知多个其他对象（观察者）其状态变化时非常理想。它非常适用于事件驱动系统，其中需要将更新推送到各个组件而不会创建它们之间的紧密耦合。这种模式允许您保持一个清晰的架构，特别是当系统的不同部分需要独立地对变化做出反应时。

真实应用案例：这种模式通常用于发送通知或警报的系统，例如聊天应用程序或股价跟踪器，在这些系统中，更新需要实时推送给用户。通过使用观察者模式，您可以轻松添加或移除通知类型，而无需改变核心逻辑。

我们将演示如何在Spring Boot中实现这种模式，通过构建一个简单的通知系统，在用户注册时发送电子邮件和短信通知。

步骤1：创建一个Observer接口

我们首先定义一个所有观察者都将实现的通用接口：

public interface Observer {
    void update(String event);
}

该接口建立了一个约定，所有观察者都必须实现update()方法，每当主题发生变化时将触发该方法。

步骤2：实现EmailObserver和SMSObserver

接下来，我们创建两个Observer接口的具体实现，用于处理电子邮件和短信通知。

EmailObserver类

public class EmailObserver implements Observer {
    @Override
    public void update(String event) {
        System.out.println("Email sent for event: " + event);
    }
}

EmailObserver处理在通知事件发生时发送电子邮件通知。

SMSObserver 类

public class SMSObserver implements Observer {
    @Override
    public void update(String event) {
        System.out.println("SMS sent for event: " + event);
    }
}

SMSObserver 类处理在收到通知时发送短信通知。

步骤 3：创建一个 UserService 类（主题）

现在我们将创建一个 UserService 类，它充当主题，当用户注册时会通知其注册的观察者。

import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {
    private List<Observer> observers = new ArrayList<>();

    // 注册观察者的方法
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    // 通知所有已注册观察者事件的方法
    public void notifyObservers(String event) {
        for (Observer observer : observers) {
            observer.update(event);
        }
    }

    // 注册新用户并通知观察者的方法
    public void registerUser(String username) {
        System.out.println("User registered: " + username);
        notifyObservers("User Registration");
    }
}

• 观察者列表：跟踪所有已注册的观察者。

• registerObserver() 方法：将新观察者添加到列表中。

• notifyObservers() 方法：当事件发生时通知所有已注册的观察者。

• registerUser() 方法：注册新用户并触发向所有观察者发送通知。

步骤 4：在控制器中使用观察者模式

最后，我们将创建一个Spring Boot控制器来暴露一个用户注册的端点。这个控制器将会使用EmailObserver和SMSObserver注册到UserService。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class UserController {
    private final UserService userService;

    public UserController() {
        this.userService = new UserService();
        // 注册观察者
        userService.registerObserver(new EmailObserver());
        userService.registerObserver(new SMSObserver());
    }

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestParam String username) {
        userService.registerUser(username);
        return ResponseEntity.ok("User registered and notifications sent!");
    }
}

• 端点 (/register)：接受一个username参数并注册用户，触发所有观察者的通知。

• 观察者：EmailObserver和SMSObserver都注册到UserService，因此它们在用户注册时会收到通知。

测试观察者模式

现在，让我们使用Postman或浏览器来测试我们的实现：

POST http://localhost:8080/api/register?username=JohnDoe

控制台中的预期输出:

User registered: JohnDoe
Email sent for event: User Registration
SMS sent for event: User Registration

系统注册用户并通知Email和SMS观察者，展示了观察者模式的灵活性。

观察者模式的实际应用

1. 通知系统：在特定事件发生时通过不同渠道（邮件、短信、推送通知）向用户发送更新。

2. 事件驱动架构: 在特定操作发生时通知多个子系统，例如用户活动或系统警报。

3. 数据流: 实时广播数据更改给各种消费者（例如实时股票价格或社交媒体动态）。

如何使用Spring Boot的依赖注入

到目前为止，我们一直在手动创建对象来演示设计模式。然而，在实际的Spring Boot应用中，依赖注入（DI）是管理对象创建的首选方法。DI允许Spring自动处理类的实例化和连接，使您的代码更加模块化、可测试和可维护。

让我们重构我们的策略模式示例，以充分利用Spring Boot强大的DI功能。这将允许我们动态切换支付策略，使用Spring的注解来管理依赖关系。

使用Spring Boot的DI更新策略模式

在我们重构的示例中，我们将利用Spring的注解，如@Component、@Service和@Autowired，来简化注入依赖的过程。

步骤1：使用@Component注解标记支付策略

首先，我们将使用@Component注解标记我们的策略实现，以便Spring可以自动检测和管理它们。

@Component("creditCardPayment")
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " with Credit Card");
    }
}

@Component("payPalPayment")
public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using PayPal");
    }
}

• @Component注解：通过添加@Component，我们告诉Spring将这些类视为Spring管理的bean。字符串值（"creditCardPayment"和"payPalPayment"）充当bean标识符。

• 灵活性：这种设置允许我们通过使用适当的bean标识符在不同策略之间切换。

步骤2：重构PaymentService以使用依赖注入

接下来，让我们修改PaymentService，使用@Autowired和@Qualifier来注入特定的支付策略。

@Service
public class PaymentService {
    private final PaymentStrategy paymentStrategy;

    @Autowired
    public PaymentService(@Qualifier("payPalPayment") PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void processPayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

• @Service注解：将PaymentService标记为Spring管理的服务bean。

• @Autowired：Spring会自动注入所需的依赖项。

• @Qualifier：指定要注入的PaymentStrategy的哪种实现。在这个例子中，我们使用的是"payPalPayment"。

• 配置简便性：通过简单更改@Qualifier的值，您可以在不改变任何业务逻辑的情况下切换支付策略。

步骤3：在控制器中使用重构后的服务

为了看到这种重构的好处，让我们更新控制器以使用我们的PaymentService：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class PaymentController {
    private final PaymentService paymentService;

    @Autowired
    public PaymentController(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    @GetMapping("/pay")
    public String makePayment(@RequestParam double amount) {
        paymentService.processPayment(amount);
        return "Payment processed using the current strategy!";
    }
}

• @Autowired：控制器会自动接收带有注入支付策略的PaymentService。

• GET端点（/pay）：当访问时，它会使用当前配置的策略（在本例中为PayPal）处理付款。

使用 DI 测试重构的策略模式

现在，让我们使用 Postman 或浏览器测试新的实现：

GET http://localhost:8080/api/pay?amount=100

预期输出:

Paid $100.0 using PayPal

如果您将 PaymentService 中的限定符更改为 "creditCardPayment"，输出将相应更改：

Paid $100.0 with Credit Card

使用依赖注入的好处

• 松耦合: 服务和控制器不需要知道支付处理的细节。它们仅依赖于 Spring 注入正确的实现。

• 模块化: 您可以通过创建带有 @Component 注解的新类并调整 @Qualifier，轻松添加新的支付方式（例如， BankTransferPayment， CryptoPayment）。

• 可配置性: 通过利用 Spring Profiles，您可以根据环境（例如，开发与生产）切换策略。

示例：您可以使用@Profile根据活动配置文件自动注入不同的策略：

@Component
@Profile("dev")
public class DevPaymentStrategy implements PaymentStrategy { /* ... */ }

@Component
@Profile("prod")
public class ProdPaymentStrategy implements PaymentStrategy { /* ... */ }

主要要点

• 通过使用Spring Boot的DI，您可以简化对象创建，提高代码的灵活性。

• 结合DI的策略模式使您能够在不更改核心业务逻辑的情况下轻松切换不同的策略。

• 使用@Qualifier和Spring Profiles让您可以根据不同的环境或需求配置应用程序的灵活性。

这种方法不仅使您的代码更清晰，还为将来更高级的配置和扩展做好准备。在下一节中，我们将探讨将您的Spring Boot应用程序提升到更高水平的最佳实践和优化技巧。

最佳实践和优化技巧

一般最佳实践

• 不要过度使用模式：仅在必要时使用。过度设计可能会使您的代码难以维护。

• 优先使用组合而非继承：策略模式和观察者模式是这一原则的很好示例。

• 保持模式的灵活性：利用接口使您的代码解耦。

性能考虑

• 单例模式：通过使用synchronized或Bill Pugh单例设计来确保线程安全。

• 工厂模式：如果创建对象开销大，则缓存对象。

• 观察者模式：如果有许多观察者，请使用异步处理以防止阻塞。

高级主题

• 使用反射与工厂模式实现动态类加载。

• 利用Spring配置文件根据环境切换策略。

• 为API端点添加Swagger文档。

结论和主要收获

在本教程中，我们探讨了一些强大的设计模式——单例模式、工厂模式、策略模式和观察者模式，并演示了如何在Spring Boot中实现它们。让我们简要总结每种模式并强调其最适合的用途：

单例模式:

• 概述: 确保一个类只有一个实例，并提供对其的全局访问点。

• 最适用于: 管理共享资源，如配置设置、数据库连接或日志服务。当您希望在整个应用程序中控制对共享实例的访问时，这是理想的选择。

工厂模式:

• 摘要: 提供一种在不指定要实例化的确切类的情况下创建对象的方式。该模式将对象创建与业务逻辑解耦。

• 最适用于: 需要根据输入条件创建不同类型对象的情况，比如通过电子邮件、短信或推送通知发送通知。这有助于使您的代码更模块化和可扩展。

策略模式:

• 摘要: 允许您定义一组算法、封装每个算法，并使它们可以互换。该模式帮助您在运行时选择算法。

• 最适用于: 当您需要动态切换不同行为或算法时，比如在电子商务应用程序中处理各种支付方式。它使您的代码灵活，并符合开闭原则。

观察者模式：

• 概述：定义对象之间的一对多依赖关系，使得当一个对象改变状态时，所有依赖它的对象都会自动收到通知。

• 最适用于：像通知服务、聊天应用中的实时更新或需要对数据变化做出反应的系统这样的事件驱动系统。它非常适合解耦组件，使系统更具伸缩性。

接下来做什么？

现在您已经学习了这些基本设计模式，请尝试将它们集成到您现有的项目中，看看它们如何改善您的代码结构和可伸缩性。以下是进一步探索的一些建议：

• 实验：尝试实现其他设计模式，如装饰者、代理和建造者，以扩展您的工具包。

• 实践：使用这些模式重构现有项目，增强其可维护性。

• 分享：如果您有任何问题或想分享经验，请随时联系！

希望本指南能帮助您了解如何在Java中有效使用设计模式。继续实验，编码愉快！