Java中的设计模式全解及电商应用场景示例
设计模式是软件开发中常用的解决方案，提供了可复用的代码结构和设计原则。本文将详细介绍Java中的23种设计模式，并结合电商实际应用场景进行示例说明。
1. 创建型模式
1.1 单例模式（Singleton Pattern）
意图：确保一个类只有一个实例，并提供一个全局访问点。
电商场景：购物车的全局管理对象。
public class ShoppingCart {private static ShoppingCart instance;private ShoppingCart() {}public static synchronized ShoppingCart getInstance() {if (instance == null) {instance = new ShoppingCart();}return instance;}
}
1.2 工厂方法模式（Factory Method Pattern）
意图：定义一个接口，让子类决定实例化哪一个类。
电商场景：根据支付方式生成对应的支付对象。
public interface Payment {void pay(double amount);
}public class CreditCardPayment implements Payment {public void pay(double amount) {System.out.println("Paid $" + amount + " via Credit Card.");}
}public class PayPalPayment implements Payment {public void pay(double amount) {System.out.println("Paid $" + amount + " via PayPal.");}
}public class PaymentFactory {public static Payment getPayment(String type) {return switch (type) {case "credit" -> new CreditCardPayment();case "paypal" -> new PayPalPayment();default -> throw new IllegalArgumentException("Invalid payment type");};}
}
1.3 抽象工厂模式（Abstract Factory Pattern）
意图：提供一个创建一系列相关或相互依赖对象的接口。
电商场景：根据用户地区生成不同风格的UI组件。
public interface Button {void render();
}public interface TextField {void render();
}public interface UIFactory {Button createButton();TextField createTextField();
}public class USUIFactory implements UIFactory {public Button createButton() {return new USButton();}public TextField createTextField() {return new USTextField();}
}public class EUUIFactory implements UIFactory {public Button createButton() {return new EUButton();}public TextField createTextField() {return new EUTextField();}
}
1.4 建造者模式（Builder Pattern）
意图：将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
电商场景：生成复杂的订单对象。
public class Order {private String orderId;private List<String> items;private double totalPrice;private Order(OrderBuilder builder) {this.orderId = builder.orderId;this.items = builder.items;this.totalPrice = builder.totalPrice;}public static class OrderBuilder {private String orderId;private List<String> items = new ArrayList<>();private double totalPrice;public OrderBuilder(String orderId) {this.orderId = orderId;}public OrderBuilder addItem(String item, double price) {items.add(item);totalPrice += price;return this;}public Order build() {return new Order(this);}}
}
1.5 原型模式（Prototype Pattern）
意图：通过复制现有实例来创建对象，而不是通过实例化类。
电商场景：批量创建类似商品。
public class Product implements Cloneable {private String name;private double price;public Product(String name, double price) {this.name = name;this.price = price;}@Overrideprotected Product clone() {try {return (Product) super.clone();} catch (CloneNotSupportedException e) {throw new RuntimeException(e);}}
}
2. 结构型模式
2.1 适配器模式（Adapter Pattern）
意图：将一个类的接口转换为客户端期望的另一种接口。
电商场景：适配不同快递公司的API。
public interface ShippingProvider {void ship(String orderId);
}public class UPSShipping {public void sendPackage(String orderId) {System.out.println("Shipping via UPS: " + orderId);}
}public class UPSAdapter implements ShippingProvider {private UPSShipping upsShipping = new UPSShipping();public void ship(String orderId) {upsShipping.sendPackage(orderId);}
}
2.2 桥接模式（Bridge Pattern）
意图：将抽象部分与其实现部分分离，使它们可以独立变化。
电商场景：实现不同的优惠券类型与折扣策略。
public interface Discount {double applyDiscount(double price);
}public class PercentageDiscount implements Discount {private double percentage;public PercentageDiscount(double percentage) {this.percentage = percentage;}public double applyDiscount(double price) {return price * (1 - percentage / 100);}
}public abstract class Coupon {protected Discount discount;public Coupon(Discount discount) {this.discount = discount;}public abstract double calculatePrice(double price);
}public class SeasonalCoupon extends Coupon {public SeasonalCoupon(Discount discount) {super(discount);}public double calculatePrice(double price) {return discount.applyDiscount(price);}
}
2.3 装饰器模式（Decorator Pattern）
意图：动态地给对象添加职责。
电商场景：添加商品额外包装服务。
public interface Product {String getDescription();double getCost();
}public class BasicProduct implements Product {public String getDescription() {return "Basic Product";}public double getCost() {return 10.0;}
}public class GiftWrapDecorator implements Product {private Product product;public GiftWrapDecorator(Product product) {this.product = product;}public String getDescription() {return product.getDescription() + ", Gift Wrapped";}public double getCost() {return product.getCost() + 5.0;}
}
2.4 代理模式（Proxy Pattern）
意图：为其他对象提供代理以控制访问。
电商场景：控制访问用户订单信息。
public interface OrderService {String getOrderDetails(String orderId);
}public class RealOrderService implements OrderService {public String getOrderDetails(String orderId) {return "Order details for: " + orderId;}
}public class OrderServiceProxy implements OrderService {private RealOrderService realService = new RealOrderService();public String getOrderDetails(String orderId) {if (checkAccess()) {return realService.getOrderDetails(orderId);}return "Access Denied!";}private boolean checkAccess() {// Mock access check logicreturn true;}
}
2.6 外观模式（Facade Pattern）
意图：为子系统中的一组接口提供一个统一的高层接口，从而简化系统的使用。
电商场景：在下单时，订单系统需要与多个子系统（库存、支付、物流）进行交互。通过外观模式，将这些复杂的调用封装到一个统一的接口中。
public class InventoryService {public boolean checkStock(String productId, int quantity) {System.out.println("Checking stock for product: " + productId);return true;}
}public class PaymentService {public boolean processPayment(String userId, double amount) {System.out.println("Processing payment for user: " + userId);return true;}
}public class ShippingService {public void shipOrder(String orderId) {System.out.println("Order " + orderId + " is being shipped.");}
}public class OrderFacade {private InventoryService inventoryService = new InventoryService();private PaymentService paymentService = new PaymentService();private ShippingService shippingService = new ShippingService();public void placeOrder(String userId, String productId, int quantity, double amount) {if (inventoryService.checkStock(productId, quantity) &&paymentService.processPayment(userId, amount)) {System.out.println("Order placed successfully!");shippingService.shipOrder("Order123");} else {System.out.println("Order placement failed.");}}
}
2.7 组合模式（Composite Pattern）
意图：将对象组合成树形结构以表示“部分-整体”的层次结构，使客户端可以统一对待单个对象和组合对象。
电商场景：电商平台上的商品分类结构（如“电子产品”下包含“手机”和“笔记本”）。
public interface Category {void display();
}public class ProductCategory implements Category {private String name;public ProductCategory(String name) {this.name = name;}@Overridepublic void display() {System.out.println(name);}
}public class CompositeCategory implements Category {private String name;private List<Category> subCategories = new ArrayList<>();public CompositeCategory(String name) {this.name = name;}public void addCategory(Category category) {subCategories.add(category);}@Overridepublic void display() {System.out.println(name);for (Category subCategory : subCategories) {subCategory.display();}}
}
使用示例：
CompositeCategory electronics = new CompositeCategory("Electronics");
electronics.addCategory(new ProductCategory("Phones"));
electronics.addCategory(new ProductCategory("Laptops"));CompositeCategory homeAppliances = new CompositeCategory("Home Appliances");
homeAppliances.addCategory(new ProductCategory("Refrigerators"));
homeAppliances.addCategory(new ProductCategory("Washing Machines"));CompositeCategory rootCategory = new CompositeCategory("All Categories");
rootCategory.addCategory(electronics);
rootCategory.addCategory(homeAppliances);rootCategory.display();
2.8 享元模式（Flyweight Pattern）
意图：通过共享相同的对象，减少内存使用并提高性能。
电商场景：商品详情页面中，显示的商品图片可能重复出现。通过享元模式，共享相同的图片对象。
import java.util.HashMap;
import java.util.Map;public class ProductImage {private String imageUrl;public ProductImage(String imageUrl) {this.imageUrl = imageUrl;}public void display(String productId) {System.out.println("Displaying " + imageUrl + " for product: " + productId);}
}public class ProductImageFactory {private static Map<String, ProductImage> imageCache = new HashMap<>();public static ProductImage getImage(String imageUrl) {if (!imageCache.containsKey(imageUrl)) {imageCache.put(imageUrl, new ProductImage(imageUrl));}return imageCache.get(imageUrl);}
}
使用示例：
ProductImage image1 = ProductImageFactory.getImage("image1.jpg");
image1.display("Product123");ProductImage image2 = ProductImageFactory.getImage("image1.jpg"); // 复用相同的对象
image2.display("Product456");
2.9 桥接模式（Bridge Pattern）
意图：将抽象部分与实现部分分离，使它们可以独立变化。
电商场景：支持不同平台的支付方式（如：支付宝和微信支付）与支付环境（如：国内支付和国际支付）。
public interface PaymentMethod {void makePayment(double amount);
}public class Alipay implements PaymentMethod {@Overridepublic void makePayment(double amount) {System.out.println("Payment of $" + amount + " made using Alipay.");}
}public class WeChatPay implements PaymentMethod {@Overridepublic void makePayment(double amount) {System.out.println("Payment of $" + amount + " made using WeChat Pay.");}
}public abstract class Payment {protected PaymentMethod method;public Payment(PaymentMethod method) {this.method = method;}public abstract void pay(double amount);
}public class DomesticPayment extends Payment {public DomesticPayment(PaymentMethod method) {super(method);}@Overridepublic void pay(double amount) {System.out.print("Domestic ");method.makePayment(amount);}
}public class InternationalPayment extends Payment {public InternationalPayment(PaymentMethod method) {super(method);}@Overridepublic void pay(double amount) {System.out.print("International ");method.makePayment(amount);}
}
使用示例：
Payment domesticAlipay = new DomesticPayment(new Alipay());
domesticAlipay.pay(100);Payment internationalWeChatPay = new InternationalPayment(new WeChatPay());
internationalWeChatPay.pay(200);
2.10 装饰器模式（Decorator Pattern）
意图：动态地给对象添加职责，而无需修改对象本身。
电商场景：在订单中动态添加促销优惠（如满减、包邮）。
public interface Order {double calculateTotal();String getDescription();
}public class BasicOrder implements Order {@Overridepublic double calculateTotal() {return 100.0;}@Overridepublic String getDescription() {return "Basic Order";}
}public abstract class OrderDecorator implements Order {protected Order order;public OrderDecorator(Order order) {this.order = order;}@Overridepublic double calculateTotal() {return order.calculateTotal();}@Overridepublic String getDescription() {return order.getDescription();}
}public class DiscountDecorator extends OrderDecorator {public DiscountDecorator(Order order) {super(order);}@Overridepublic double calculateTotal() {return super.calculateTotal() - 10.0; // 满减优惠}@Overridepublic String getDescription() {return super.getDescription() + " with Discount";}
}
使用示例：
Order order = new BasicOrder();
System.out.println(order.getDescription() + ": $" + order.calculateTotal());Order discountedOrder = new DiscountDecorator(order);
System.out.println(discountedOrder.getDescription() + ": $" + discountedOrder.calculateTotal());
总结
以上补充了外观模式、组合模式、享元模式、桥接模式和装饰器模式的详细内容及电商示例代码。结构型模式主要用于处理类和对象的组合关系，通过这些模式，开发者可以设计出更灵活、高效且易维护的代码结构。结合实际业务场景，能够更直观地理解这些模式的意义及作用。
3. 行为型模式
3.1 策略模式（Strategy Pattern）
意图：定义一系列算法，使得它们可以互换。
电商场景：实现不同的商品排序策略。
public interface SortStrategy {void sort(List<String> items);
}public class PriceSortStrategy implements SortStrategy {public void sort(List<String> items) {// Sort by price}
}public class RatingSortStrategy implements SortStrategy {public void sort(List<String> items) {// Sort by rating}
}
3.2 模板方法模式（Template Method Pattern）
意图：定义一个操作的算法骨架，而将某些步骤的实现延迟到子类。
电商场景：处理不同类型订单（普通订单、预售订单）的通用逻辑。
public abstract class OrderProcessor {public final void processOrder() {validateOrder();deductInventory();calculatePrice();createInvoice();}protected abstract void validateOrder();protected abstract void deductInventory();protected abstract void calculatePrice();private void createInvoice() {System.out.println("Invoice created!");}
}public class RegularOrderProcessor extends OrderProcessor {@Overrideprotected void validateOrder() {System.out.println("Validating regular order...");}@Overrideprotected void deductInventory() {System.out.println("Deducting inventory for regular order...");}@Overrideprotected void calculatePrice() {System.out.println("Calculating price for regular order...");}
}
3.3 观察者模式（Observer Pattern）
意图：定义对象间的一对多依赖关系，当一个对象状态改变时，其依赖者会收到通知。
电商场景：实现商品库存变化的通知功能。
public interface Observer {void update(String product, int quantity);
}public class Customer implements Observer {private String name;public Customer(String name) {this.name = name;}public void update(String product, int quantity) {System.out.println(name + " notified: " + product + " is back in stock with quantity " + quantity);}
}public class ProductStock {private List<Observer> observers = new ArrayList<>();private String product;private int quantity;public ProductStock(String product) {this.product = product;}public void addObserver(Observer observer) {observers.add(observer);}public void setQuantity(int quantity) {this.quantity = quantity;notifyObservers();}private void notifyObservers() {for (Observer observer : observers) {observer.update(product, quantity);}}
}
3.4 状态模式（State Pattern）
意图：允许对象在其内部状态改变时改变其行为。
电商场景：订单状态管理（如：待支付、已支付、已发货等）。
public interface OrderState {void handleOrder();
}public class PendingState implements OrderState {public void handleOrder() {System.out.println("Order is pending payment.");}
}public class PaidState implements OrderState {public void handleOrder() {System.out.println("Order has been paid. Preparing for shipment.");}
}public class ShippedState implements OrderState {public void handleOrder() {System.out.println("Order has been shipped.");}
}public class Order {private OrderState state;public void setState(OrderState state) {this.state = state;}public void processOrder() {state.handleOrder();}
}
3.5 命令模式（Command Pattern）
意图：将请求封装为对象，从而可以用不同的请求对客户端进行参数化。
电商场景：实现商品的批量操作（如：上下架、删除）。
public interface Command {void execute();
}public class AddProductCommand implements Command {private Product product;public AddProductCommand(Product product) {this.product = product;}public void execute() {System.out.println("Adding product: " + product.getName());}
}public class RemoveProductCommand implements Command {private Product product;public RemoveProductCommand(Product product) {this.product = product;}public void execute() {System.out.println("Removing product: " + product.getName());}
}public class CommandInvoker {private List<Command> commands = new ArrayList<>();public void addCommand(Command command) {commands.add(command);}public void executeCommands() {for (Command command : commands) {command.execute();}commands.clear();}
}
3.6 责任链模式（Chain of Responsibility Pattern）
意图：将请求沿着处理者链传递，直到有一个处理者处理它。
电商场景：实现订单的审核流程（如：库存检查、支付检查）。
public abstract class OrderHandler {protected OrderHandler nextHandler;public void setNextHandler(OrderHandler nextHandler) {this.nextHandler = nextHandler;}public abstract void handleOrder(Order order);
}public class InventoryCheckHandler extends OrderHandler {public void handleOrder(Order order) {if (order.hasSufficientInventory()) {System.out.println("Inventory check passed.");if (nextHandler != null) {nextHandler.handleOrder(order);}} else {System.out.println("Inventory check failed.");}}
}public class PaymentCheckHandler extends OrderHandler {public void handleOrder(Order order) {if (order.isPaid()) {System.out.println("Payment check passed.");if (nextHandler != null) {nextHandler.handleOrder(order);}} else {System.out.println("Payment check failed.");}}
}
3.7 迭代器模式（Iterator Pattern）
意图：提供一种方法访问一个聚合对象中的元素，而无需暴露其内部表示。
电商场景：实现订单集合的迭代。
public interface Iterator<T> {boolean hasNext();T next();
}public class OrderCollection implements Iterable<Order> {private List<Order> orders = new ArrayList<>();public void addOrder(Order order) {orders.add(order);}public Iterator<Order> iterator() {return new OrderIterator(orders);}private class OrderIterator implements Iterator<Order> {private int index = 0;public boolean hasNext() {return index < orders.size();}public Order next() {return orders.get(index++);}}
}
3.8 备忘录模式（Memento Pattern）
意图：捕获对象的内部状态，并在以后恢复。
电商场景：实现购物车的撤销操作。
public class ShoppingCartMemento {private List<String> items;public ShoppingCartMemento(List<String> items) {this.items = new ArrayList<>(items);}public List<String> getItems() {return items;}
}public class ShoppingCart {private List<String> items = new ArrayList<>();public void addItem(String item) {items.add(item);}public ShoppingCartMemento save() {return new ShoppingCartMemento(items);}public void restore(ShoppingCartMemento memento) {items = memento.getItems();}
}
总结
通过本文，我们详细讲解了Java中的23种设计模式，并结合电商场景给出了对应的示例代码。这些设计模式不仅能够解决常见开发问题，还能提升代码的复用性、可扩展性和可维护性。希望这些内容能为你的学习和实际开发带来帮助！