四、行为型模式：对象间的职责分配与通信
行为型模式关注对象之间的职责分配和通信方式，使对象能够更好地协作。
4.1 策略模式（Strategy）—— 算法族可互换
策略模式定义一系列算法，并将每个算法封装起来，使它们可以互相替换。
// 策略接口
@FunctionalInterface
public interface DiscountStrategy {
BigDecimal calculate(BigDecimal amount);
}
// 具体策略
public class NoDiscountStrategy implements DiscountStrategy {
@Override
public BigDecimal calculate(BigDecimal amount) {
return BigDecimal.ZERO;
}
}
public class PercentageDiscountStrategy implements DiscountStrategy {
private final double percentage;
public PercentageDiscountStrategy(double percentage) {
this.percentage = percentage;
}
@Override
public BigDecimal calculate(BigDecimal amount) {
return amount.multiply(BigDecimal.valueOf(percentage / 100));
}
}
public class FixedAmountDiscountStrategy implements DiscountStrategy {
private final BigDecimal discountAmount;
public FixedAmountDiscountStrategy(BigDecimal discountAmount) {
this.discountAmount = discountAmount;
}
@Override
public BigDecimal calculate(BigDecimal amount) {
return discountAmount.min(amount);
}
}
public class BuyXGetYFreeStrategy implements DiscountStrategy {
private final int buyQuantity;
private final int freeQuantity;
public BuyXGetYFreeStrategy(int buyQuantity, int freeQuantity) {
this.buyQuantity = buyQuantity;
this.freeQuantity = freeQuantity;
}
@Override
public BigDecimal calculate(BigDecimal amount) {
// 简化逻辑：假设单价相同
BigDecimal unitPrice = amount.divide(BigDecimal.valueOf(buyQuantity + freeQuantity),
RoundingMode.HALF_UP);
return unitPrice.multiply(BigDecimal.valueOf(freeQuantity));
}
}
// 上下文
public class OrderCalculator {
private DiscountStrategy discountStrategy;
public OrderCalculator(DiscountStrategy discountStrategy) {
this.discountStrategy = discountStrategy;
}
public void setDiscountStrategy(DiscountStrategy discountStrategy) {
this.discountStrategy = discountStrategy;
}
public OrderResult calculate(Order order) {
BigDecimal subtotal = order.calculateSubtotal();
BigDecimal discount = discountStrategy.calculate(subtotal);
BigDecimal total = subtotal.subtract(discount);
return new OrderResult(subtotal, discount, total);
}
}
// 使用Lambda表达式简化策略
public class ShoppingCart {
public static void main(String[] args) {
Order order = new Order(199.99);
// 使用内置函数式接口
OrderCalculator calculator = new OrderCalculator(amount -> amount.multiply(new BigDecimal("0.1")));
// 或者使用方法引用
calculator.setDiscountStrategy(OrderCalculator::vipDiscount);
}
}
4.2 观察者模式（Observer）—— 事件通知
观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖者自动收到通知。
// 观察者接口
public interface OrderObserver {
void onOrderCreated(OrderEvent event);
void onOrderPaid(OrderEvent event);
void onOrderCancelled(OrderEvent event);
}
// 具体观察者
@Component
public class InventoryObserver implements OrderObserver {
@Override
public void onOrderCreated(OrderEvent event) {
// 锁定库存
System.out.println("Inventory: Reserving stock for order " + event.getOrderId());
}
@Override
public void onOrderPaid(OrderEvent event) {
// 扣减库存
System.out.println("Inventory: Deducting stock for order " + event.getOrderId());
}
@Override
public void onOrderCancelled(OrderEvent event) {
// 释放库存
System.out.println("Inventory: Releasing stock for order " + event.getOrderId());
}
}
@Component
public class NotificationObserver implements OrderObserver {
@Override
public void onOrderCreated(OrderEvent event) {
System.out.println("Notification: Sending order confirmation to user " + event.getUserId());
}
@Override
public void onOrderPaid(OrderEvent event) {
System.out.println("Notification: Sending payment confirmation");
}
@Override
public void onOrderCancelled(OrderEvent event) {
System.out.println("Notification: Sending cancellation notification");
}
}
@Component
public class LoyaltyObserver implements OrderObserver {
@Override
public void onOrderCreated(OrderEvent event) {
// 不处理
}
@Override
public void onOrderPaid(OrderEvent event) {
// 积分累积
System.out.println("Loyalty: Adding points for user " + event.getUserId());
}
@Override
public void onOrderCancelled(OrderEvent event) {
// 扣减积分
System.out.println("Loyalty: Reversing points for user " + event.getUserId());
}
}
// 主题（被观察者）
@Service
public class OrderEventPublisher {
private final Map<Class<?>, List<OrderObserver>> observers = new HashMap<>();
@PostConstruct
public void init() {
// 注册观察者
register(OrderCreatedEvent.class, inventoryObserver);
register(OrderCreatedEvent.class, notificationObserver);
register(OrderPaidEvent.class, inventoryObserver);
register(OrderPaidEvent.class, notificationObserver);
register(OrderPaidEvent.class, loyaltyObserver);
register(OrderCancelledEvent.class, inventoryObserver);
register(OrderCancelledEvent.class, notificationObserver);
}
public void register(Class<?> eventType, OrderObserver observer) {
observers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(observer);
}
public void publish(OrderEvent event) {
List<OrderObserver> listeners = observers.get(event.getClass());
if (listeners != null) {
// 异步通知，避免影响主流程
listeners.forEach(observer -> {
CompletableFuture.runAsync(() -> {
if (event instanceof OrderCreatedEvent) {
observer.onOrderCreated(event);
} else if (event instanceof OrderPaidEvent) {
observer.onOrderPaid(event);
} else if (event instanceof OrderCancelledEvent) {
observer.onOrderCancelled(event);
}
});
});
}
}
}
// 使用Spring事件机制（替代手动实现）
@Component
public class SpringEventPublisher {
@Autowired
private ApplicationEventPublisher publisher;
public void createOrder(Order order) {
// 业务逻辑...
publisher.publishEvent(new OrderCreatedEvent(order));
}
}
@Component
@EventListener
public class SpringInventoryListener {
public void handleOrderCreated(OrderCreatedEvent event) {
// 处理库存...
}
}
4.3 责任链模式（Chain of Responsibility）
责任链模式将请求沿着处理链传递，直到有一个处理器处理它。
// 请求对象
public class LeaveRequest {
private String employeeName;
private int days;
private String reason;
// getters/setters
}
// 处理器抽象
public abstract class LeaveHandler {
protected LeaveHandler nextHandler;
public void setNextHandler(LeaveHandler nextHandler) {
this.nextHandler = nextHandler;
}
public abstract void handleRequest(LeaveRequest request);
}
// 具体处理器
public class TeamLeadHandler extends LeaveHandler {
private static final int MAX_DAYS = 3;
@Override
public void handleRequest(LeaveRequest request) {
if (request.getDays() <= MAX_DAYS) {
System.out.println("Team Lead approved " + request.getDays() + " days leave for " + request.getEmployeeName());
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
System.out.println("Request cannot be processed");
}
}
}
public class DepartmentManagerHandler extends LeaveHandler {
private static final int MAX_DAYS = 10;
@Override
public void handleRequest(LeaveRequest request) {
if (request.getDays() <= MAX_DAYS) {
System.out.println("Department Manager approved " + request.getDays() + " days leave for " + request.getEmployeeName());
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
public class HRHandler extends LeaveHandler {
@Override
public void handleRequest(LeaveRequest request) {
System.out.println("HR approved " + request.getDays() + " days leave for " + request.getEmployeeName());
// HR可以批准任意天数，但需要特殊审批流程
}
}
// 构建责任链
public class LeaveApprovalChain {
public static LeaveHandler buildChain() {
TeamLeadHandler teamLead = new TeamLeadHandler();
DepartmentManagerHandler manager = new DepartmentManagerHandler();
HRHandler hr = new HRHandler();
teamLead.setNextHandler(manager);
manager.setNextHandler(hr);
return teamLead;
}
}
// 使用示例（Web框架中的过滤器链）
public class FilterChainDemo {
public interface Filter {
void doFilter(Request request, Response response, FilterChain chain);
}
public class AuthenticationFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
if (request.getHeader("Authorization") != null) {
System.out.println("Authentication passed");
chain.doFilter(request, response);
} else {
response.setStatus(401);
System.out.println("Authentication failed");
}
}
}
public class LoggingFilter implements Filter {
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
System.out.println("Request: " + request.getPath());
chain.doFilter(request, response);
System.out.println("Response status: " + response.getStatus());
}
}
public class FilterChain {
private List<Filter> filters = new ArrayList<>();
private int index = 0;
public void addFilter(Filter filter) {
filters.add(filter);
}
public void doFilter(Request request, Response response) {
if (index < filters.size()) {
Filter filter = filters.get(index);
index++;
filter.doFilter(request, response, this);
}
}
}
}
4.4 模板方法模式（Template Method）
模板方法模式定义算法的骨架，将某些步骤延迟到子类实现。
// 抽象模板
public abstract class DataProcessor {
// 模板方法（final防止子类修改）
public final void process() {
readData();
processData();
writeData();
if (needValidation()) {
validate();
}
}
// 具体方法（子类共享）
protected void readData() {
System.out.println("Reading data from source");
}
// 抽象方法（子类必须实现）
protected abstract void processData();
// 具体方法（可被子类覆盖）
protected void writeData() {
System.out.println("Writing data to destination");
}
// 钩子方法（子类可选覆盖）
protected boolean needValidation() {
return false;
}
protected void validate() {
System.out.println("Validating data");
}
}
// 具体子类
public class CsvDataProcessor extends DataProcessor {
@Override
protected void processData() {
System.out.println("Processing CSV data: parsing columns, handling quotes");
}
@Override
protected boolean needValidation() {
return true;
}
@Override
protected void validate() {
System.out.println("Validating CSV format and data types");
}
}
public class JsonDataProcessor extends DataProcessor {
@Override
protected void processData() {
System.out.println("Processing JSON data: parsing objects, arrays");
}
@Override
protected void writeData() {
System.out.println("Writing JSON data to API endpoint");
}
}
// 使用示例（Spring中的模板方法）
// JdbcTemplate, RestTemplate, RedisTemplate 都使用了模板方法模式
public class JdbcTemplateExample {
public void demo() {
JdbcTemplate template = new JdbcTemplate(dataSource);
// 模板方法 execute
template.execute((PreparedStatementCallback<Object>) ps -> {
// 用户只需实现具体逻辑
return null;
});
}
}
4.5 状态模式（State）—— 对象状态机
状态模式允许对象在内部状态改变时改变其行为。
// 状态接口
public interface OrderState {
void pay(Order order);
void cancel(Order order);
void ship(Order order);
void deliver(Order order);
}
// 具体状态
public class PendingState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("Payment received, order is now PAID");
order.setState(new PaidState());
}
@Override
public void cancel(Order order) {
System.out.println("Order cancelled");
order.setState(new CancelledState());
}
@Override
public void ship(Order order) {
System.out.println("Cannot ship unpaid order");
throw new IllegalStateException("Order not paid");
}
@Override
public void deliver(Order order) {
System.out.println("Cannot deliver unpaid order");
throw new IllegalStateException("Order not paid");
}
}
public class PaidState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("Order already paid");
}
@Override
public void cancel(Order order) {
System.out.println("Order cancelled, refund initiated");
order.setState(new CancelledState());
}
@Override
public void ship(Order order) {
System.out.println("Order shipped");
order.setState(new ShippedState());
}
@Override
public void deliver(Order order) {
System.out.println("Cannot deliver, order not shipped yet");
throw new IllegalStateException("Order not shipped");
}
}
public class ShippedState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("Order already paid");
}
@Override
public void cancel(Order order) {
System.out.println("Cannot cancel shipped order");
throw new IllegalStateException("Order already shipped");
}
@Override
public void ship(Order order) {
System.out.println("Order already shipped");
}
@Override
public void deliver(Order order) {
System.out.println("Order delivered");
order.setState(new DeliveredState());
}
}
public class DeliveredState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("Order already paid");
}
@Override
public void cancel(Order order) {
System.out.println("Cannot cancel delivered order");
throw new IllegalStateException("Order already delivered");
}
@Override
public void ship(Order order) {
System.out.println("Order already delivered");
}
@Override
public void deliver(Order order) {
System.out.println("Order already delivered");
}
}
public class CancelledState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("Cannot pay cancelled order");
throw new IllegalStateException("Order cancelled");
}
@Override
public void cancel(Order order) {
System.out.println("Order already cancelled");
}
@Override
public void ship(Order order) {
System.out.println("Cannot ship cancelled order");
throw new IllegalStateException("Order cancelled");
}
@Override
public void deliver(Order order) {
System.out.println("Cannot deliver cancelled order");
throw new IllegalStateException("Order cancelled");
}
}
// 上下文
public class Order {
private OrderState state;
private String orderId;
public Order(String orderId) {
this.orderId = orderId;
this.state = new PendingState(); // 初始状态
}
public void setState(OrderState state) {
this.state = state;
System.out.println("Order " + orderId + " state changed to: " + state.getClass().getSimpleName());
}
public void pay() {
state.pay(this);
}
public void cancel() {
state.cancel(this);
}
public void ship() {
state.ship(this);
}
public void deliver() {
state.deliver(this);
}
}
// 使用示例
public class OrderStateDemo {
public static void main(String[] args) {
Order order = new Order("ORD-001");
// 正常流程
order.pay(); // Payment received, order is now PAID
order.ship(); // Order shipped
order.deliver(); // Order delivered
// 异常流程
Order order2 = new Order("ORD-002");
order2.cancel(); // Order cancelled
order2.pay(); // Exception: Cannot pay cancelled order
}
}
