Java 设计模式最佳实践构建可维护的应用别叫我大神叫我 Alex 就好。一、引言大家好我是 Alex。设计模式是软件开发中解决常见问题的可重用方案。它们是经过验证的最佳实践可以帮助我们构建更可维护、更可扩展的应用。今天我想和大家分享一下 Java 中常用的设计模式及其最佳实践帮助大家更好地应用这些模式。二、设计模式概述设计模式分为三大类创建型模式负责对象的创建包括单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式结构型模式负责对象的组合包括适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式、代理模式行为型模式负责对象的行为包括策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式三、创建型模式1. 单例模式用途确保一个类只有一个实例并提供一个全局访问点实现方式饿汉式类加载时创建实例懒汉式首次使用时创建实例双重检查锁定避免线程安全问题静态内部类利用类加载机制保证线程安全枚举最简洁、最安全的实现方式示例// 枚举实现推荐 enum Singleton { INSTANCE; public void doSomething() { System.out.println(Singleton is doing something); } } // 使用 Singleton.INSTANCE.doSomething(); // 静态内部类实现 public class Singleton { private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE new Singleton(); } public static Singleton getInstance() { return SingletonHolder.INSTANCE; } }2. 工厂模式用途创建对象时不暴露创建逻辑而是使用共同的接口来指向新创建的对象实现方式简单工厂一个工厂类负责创建所有产品工厂方法每个产品有对应的工厂类抽象工厂创建相关或依赖对象的家族示例// 产品接口 interface Product { void use(); } // 具体产品 class ConcreteProductA implements Product { Override public void use() { System.out.println(Using Product A); } } class ConcreteProductB implements Product { Override public void use() { System.out.println(Using Product B); } } // 工厂接口 interface Factory { Product createProduct(); } // 具体工厂 class ConcreteFactoryA implements Factory { Override public Product createProduct() { return new ConcreteProductA(); } } class ConcreteFactoryB implements Factory { Override public Product createProduct() { return new ConcreteProductB(); } } // 使用 Factory factory new ConcreteFactoryA(); Product product factory.createProduct(); product.use();3. 建造者模式用途将复杂对象的构建过程与表示分离使得同样的构建过程可以创建不同的表示实现方式产品类需要构建的复杂对象建造者接口定义构建产品的方法具体建造者实现建造者接口指挥者负责使用建造者构建产品示例// 产品类 class Product { private String partA; private String partB; private String partC; public void setPartA(String partA) { this.partA partA; } public void setPartB(String partB) { this.partB partB; } public void setPartC(String partC) { this.partC partC; } Override public String toString() { return Product{ partA partA \ , partB partB \ , partC partC \ }; } } // 建造者接口 interface Builder { void buildPartA(); void buildPartB(); void buildPartC(); Product getResult(); } // 具体建造者 class ConcreteBuilder implements Builder { private Product product new Product(); Override public void buildPartA() { product.setPartA(Part A); } Override public void buildPartB() { product.setPartB(Part B); } Override public void buildPartC() { product.setPartC(Part C); } Override public Product getResult() { return product; } } // 指挥者 class Director { public Product construct(Builder builder) { builder.buildPartA(); builder.buildPartB(); builder.buildPartC(); return builder.getResult(); } } // 使用 Director director new Director(); Builder builder new ConcreteBuilder(); Product product director.construct(builder); System.out.println(product);四、结构型模式1. 适配器模式用途将一个类的接口转换成客户端期望的另一个接口使得原本不兼容的类可以一起工作实现方式类适配器通过继承实现对象适配器通过组合实现示例// 目标接口 interface Target { void request(); } // 适配者类 class Adaptee { public void specificRequest() { System.out.println(Adaptees specific request); } } // 类适配器 class ClassAdapter extends Adaptee implements Target { Override public void request() { specificRequest(); } } // 对象适配器 class ObjectAdapter implements Target { private Adaptee adaptee; public ObjectAdapter(Adaptee adaptee) { this.adaptee adaptee; } Override public void request() { adaptee.specificRequest(); } } // 使用 Target target1 new ClassAdapter(); target1.request(); Target target2 new ObjectAdapter(new Adaptee()); target2.request();2. 装饰器模式用途动态地给对象添加额外的责任增强对象的功能实现方式组件接口定义对象的接口具体组件实现组件接口装饰器实现组件接口并包含组件的引用具体装饰器实现具体的装饰功能示例// 组件接口 interface Component { void operation(); } // 具体组件 class ConcreteComponent implements Component { Override public void operation() { System.out.println(ConcreteComponents operation); } } // 装饰器 abstract class Decorator implements Component { protected Component component; public Decorator(Component component) { this.component component; } Override public void operation() { component.operation(); } } // 具体装饰器 class ConcreteDecoratorA extends Decorator { public ConcreteDecoratorA(Component component) { super(component); } Override public void operation() { super.operation(); addBehavior(); } private void addBehavior() { System.out.println(ConcreteDecoratorAs additional behavior); } } class ConcreteDecoratorB extends Decorator { public ConcreteDecoratorB(Component component) { super(component); } Override public void operation() { super.operation(); addBehavior(); } private void addBehavior() { System.out.println(ConcreteDecoratorBs additional behavior); } } // 使用 Component component new ConcreteComponent(); Component decoratedComponent new ConcreteDecoratorB(new ConcreteDecoratorA(component)); decoratedComponent.operation();3. 代理模式用途为其他对象提供一个代理以控制对这个对象的访问实现方式静态代理手动创建代理类动态代理运行时生成代理类如 JDK 动态代理、CGLIB示例// 接口 interface Subject { void request(); } // 真实主题 class RealSubject implements Subject { Override public void request() { System.out.println(RealSubjects request); } } // 静态代理 class StaticProxy implements Subject { private RealSubject realSubject; public StaticProxy(RealSubject realSubject) { this.realSubject realSubject; } Override public void request() { System.out.println(Before request); realSubject.request(); System.out.println(After request); } } // 使用 Subject subject new StaticProxy(new RealSubject()); subject.request(); // JDK 动态代理 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; class DynamicProxy implements InvocationHandler { private Object target; public DynamicProxy(Object target) { this.target target; } Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(Before invocation); Object result method.invoke(target, args); System.out.println(After invocation); return result; } } // 使用 Subject realSubject new RealSubject(); Subject proxySubject (Subject) Proxy.newProxyInstance( realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), new DynamicProxy(realSubject) ); proxySubject.request();五、行为型模式1. 策略模式用途定义一系列算法将每个算法封装起来并使它们可以互相替换实现方式策略接口定义算法的接口具体策略实现策略接口上下文使用策略的类示例// 策略接口 interface Strategy { int doOperation(int num1, int num2); } // 具体策略 class AddStrategy implements Strategy { Override public int doOperation(int num1, int num2) { return num1 num2; } } class SubtractStrategy implements Strategy { Override public int doOperation(int num1, int num2) { return num1 - num2; } } class MultiplyStrategy implements Strategy { Override public int doOperation(int num1, int num2) { return num1 * num2; } } // 上下文 class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy strategy; } public int executeStrategy(int num1, int num2) { return strategy.doOperation(num1, num2); } } // 使用 Context context new Context(new AddStrategy()); System.out.println(10 5 context.executeStrategy(10, 5)); context new Context(new SubtractStrategy()); System.out.println(10 - 5 context.executeStrategy(10, 5)); context new Context(new MultiplyStrategy()); System.out.println(10 * 5 context.executeStrategy(10, 5));2. 观察者模式用途定义对象间的一种一对多依赖关系当一个对象的状态发生变化时所有依赖于它的对象都得到通知并被自动更新实现方式主题维护观察者列表提供添加和删除观察者的方法观察者定义更新接口具体主题实现主题接口维护状态具体观察者实现观察者接口响应主题的通知示例// 观察者接口 interface Observer { void update(); } // 主题接口 interface Subject { void registerObserver(Observer observer); void removeObserver(Observer observer); void notifyObservers(); } // 具体主题 class ConcreteSubject implements Subject { private ListObserver observers new ArrayList(); private int state; public int getState() { return state; } public void setState(int state) { this.state state; notifyObservers(); } Override public void registerObserver(Observer observer) { observers.add(observer); } Override public void removeObserver(Observer observer) { observers.remove(observer); } Override public void notifyObservers() { for (Observer observer : observers) { observer.update(); } } } // 具体观察者 class ConcreteObserver implements Observer { private ConcreteSubject subject; private int observerState; public ConcreteObserver(ConcreteSubject subject) { this.subject subject; subject.registerObserver(this); } Override public void update() { observerState subject.getState(); System.out.println(Observer state updated: observerState); } } // 使用 ConcreteSubject subject new ConcreteSubject(); ConcreteObserver observer1 new ConcreteObserver(subject); ConcreteObserver observer2 new ConcreteObserver(subject); subject.setState(10); subject.setState(20);3. 责任链模式用途将请求的发送者和接收者解耦使多个对象都有机会处理请求实现方式处理器接口定义处理请求的方法具体处理器实现处理器接口处理请求或传递给下一个处理器客户端创建处理器链并发送请求示例// 处理器接口 interface Handler { void setNext(Handler next); void handleRequest(int request); } // 具体处理器 class ConcreteHandler1 implements Handler { private Handler next; Override public void setNext(Handler next) { this.next next; } Override public void handleRequest(int request) { if (request 0 request 10) { System.out.println(ConcreteHandler1 handled request: request); } else if (next ! null) { next.handleRequest(request); } } } class ConcreteHandler2 implements Handler { private Handler next; Override public void setNext(Handler next) { this.next next; } Override public void handleRequest(int request) { if (request 10 request 20) { System.out.println(ConcreteHandler2 handled request: request); } else if (next ! null) { next.handleRequest(request); } } } class ConcreteHandler3 implements Handler { private Handler next; Override public void setNext(Handler next) { this.next next; } Override public void handleRequest(int request) { if (request 20 request 30) { System.out.println(ConcreteHandler3 handled request: request); } else if (next ! null) { next.handleRequest(request); } } } // 使用 Handler handler1 new ConcreteHandler1(); Handler handler2 new ConcreteHandler2(); Handler handler3 new ConcreteHandler3(); handler1.setNext(handler2); handler2.setNext(handler3); // 发送请求 handler1.handleRequest(5); handler1.handleRequest(15); handler1.handleRequest(25); handler1.handleRequest(35);六、设计模式最佳实践1. 选择合适的设计模式根据问题选择根据具体的问题场景选择合适的设计模式理解模式的意图深入理解设计模式的意图和适用场景避免过度设计不要为了使用设计模式而使用设计模式2. 实现设计模式遵循设计原则遵循 SOLID 原则保持简单尽量保持设计模式的实现简洁明了考虑性能在实现设计模式时考虑性能影响3. 测试设计模式单元测试测试设计模式的各个组件集成测试测试设计模式在系统中的集成性能测试测试设计模式的性能影响七、实战案例案例电商系统中的设计模式需求构建一个电商系统支持产品管理、订单管理、支付等功能设计模式应用单例模式用于系统配置、数据库连接池等工厂模式用于创建不同类型的产品建造者模式用于构建复杂的订单对象适配器模式用于集成不同的支付系统装饰器模式用于添加产品的附加功能策略模式用于实现不同的支付策略观察者模式用于订单状态变化的通知责任链模式用于处理订单的审批流程实现// 单例模式系统配置 public class SystemConfig { private static class ConfigHolder { private static final SystemConfig INSTANCE new SystemConfig(); } private SystemConfig() {} public static SystemConfig getInstance() { return ConfigHolder.INSTANCE; } // 配置方法 public String getConfig(String key) { // 实现配置获取 return config value; } } // 工厂模式产品工厂 interface ProductFactory { Product createProduct(); } class ElectronicProductFactory implements ProductFactory { Override public Product createProduct() { return new ElectronicProduct(); } } class ClothingProductFactory implements ProductFactory { Override public Product createProduct() { return new ClothingProduct(); } } // 建造者模式订单建造者 class OrderBuilder { private Order order new Order(); public OrderBuilder withId(long id) { order.setId(id); return this; } public OrderBuilder withCustomer(Customer customer) { order.setCustomer(customer); return this; } public OrderBuilder withProducts(ListProduct products) { order.setProducts(products); return this; } public Order build() { return order; } } // 策略模式支付策略 interface PaymentStrategy { void pay(double amount); } class CreditCardPaymentStrategy implements PaymentStrategy { Override public void pay(double amount) { System.out.println(Paying amount using credit card); } } class PayPalPaymentStrategy implements PaymentStrategy { Override public void pay(double amount) { System.out.println(Paying amount using PayPal); } } // 观察者模式订单状态观察者 interface OrderObserver { void update(Order order); } class EmailNotificationObserver implements OrderObserver { Override public void update(Order order) { System.out.println(Sending email notification for order order.getId()); } } class SMSNotificationObserver implements OrderObserver { Override public void update(Order order) { System.out.println(Sending SMS notification for order order.getId()); } }结果系统设计清晰易于维护和扩展各个组件职责明确耦合度低系统具有良好的可测试性八、总结设计模式是软件开发中的重要工具它们可以帮助我们构建更可维护、更可扩展的应用。通过合理地应用设计模式我们可以提高代码的质量和可读性减少重复代码提高开发效率。这其实可以更优雅一点。希望这篇文章能帮助大家更好地理解和应用 Java 设计模式。如果你有任何问题欢迎在评论区留言。关于作者我是 Alex一个在 CSDN 写 Java 架构思考的暖男。喜欢手冲咖啡养了一只叫Java的拉布拉多。如果我的文章对你有帮助欢迎关注我一起探讨 Java 技术的优雅之道。