泛型设计模式实践

学海无涯，志当存远。燃心砺志，奋进不辍。

愿诸君得此鸡汤，如沐春风，事业有成。

若觉此言甚善，烦请赐赞一枚，共励学途，同铸辉煌！

为解决在设计框架或库时遇到的类型安全问题，或者处理多态集合时的挑战。
希望优化代码结构，减少重复，提高类型安全。
需要结合常见的设计模式，比如工厂模式、策略模式等，展示泛型如何在这些模式中发挥作用。常见的泛型设计模式，比如类型安全的异构容器、泛型单例工厂、策略模式中的泛型应用，以及构建器模式。
需要具体说明每个模式的应用场景、实现方式和优势。
例如，类型安全的异构容器使用Class对象作为键，存储不同类型的实例，
这样可以在编译时保证类型安全，避免运行时错误。痛点难点，比如处理不同类型数据时的强制转换，或者如何避免使用Object类型带来的类型不安全。
此时，展示如何通过泛型消除显式转换，提升代码的可读性和安全性。
例如，使用泛型方法替代重载，减少代码重复。桥接方法在类型擦除中的作用，以及如何利用反射获取泛型信息，
比如通过ParameterizedType来动态获取类型参数。
但要注意反射的使用场景和限制，比如类型擦除后的信息保留情况。实际项目中应用这些设计模式，结合相应的代码示例，并解释每个步骤的设计考虑。
比如，在工厂模式中使用泛型创建不同产品类型的实例，避免多个工厂类的问题。
或者，在策略模式中使用泛型接口，使策略实现能够处理不同类型的数据。潜在的问题和最佳实践，比如避免过度使用泛型导致代码复杂化，或者如何处理类型擦除带来的限制。
例如，在创建泛型数组时，使用通配符类型或@SuppressWarnings注解，并解释为何需要谨慎处理。最后，总结这些设计模式如何综合提升代码的灵活性和可维护性，强调类型安全的重要性，
以及在维护和扩展代码时的便利。

一、类型安全的异构容器（Type-Safe Heterogeneous Container）

二、泛型工厂模式（Generic Factory）

三、策略模式 + 泛型（Generic Strategy）

四、构建器模式 + 泛型（Generic Builder）

五、模板方法模式 + 泛型（Generic Template Method）

六、责任链模式 + 泛型

七、观察者模式 + 泛型

八、应用建议

1.类型边界明确化：始终为泛型参数定义明确的边界

2.避免类型擦除问题：在需要保留类型信息时使用Class对象

3.合理使用通配符：提高API灵活性

总结：泛型设计模式的核心价值

在Java开发中，结合泛型与设计模式可以显著提升代码的类型安全性、复用性和可维护性。以下是几种典型的泛型设计模式实践，通过具体场景说明其优势：

一、类型安全的异构容器（Type-Safe Heterogeneous Container）

场景：需要在一个容器中存储和获取不同类型的对象，同时保证类型安全。
实现：使用Class<T>对象作为键，动态关联类型与值。

public class TypeSafeContainer {private Map<Class<?>, Object> container = new HashMap<>();public <T> void put(Class<T> type, T instance) {container.put(type, instance);}public <T> T get(Class<T> type) {return type.cast(container.get(type));}// 使用示例public static void main(String[] args) {TypeSafeContainer container = new TypeSafeContainer();container.put(String.class, "Hello");container.put(Integer.class, 42);String str = container.get(String.class);  // 无需强制转换Integer num = container.get(Integer.class); // 类型安全}
}

优势：

避免使用Object类型和强制转换，消除ClassCastException风险。
通过Class<T>类型检查确保键值对类型一致性。

二、泛型工厂模式（Generic Factory）

场景：创建不同类型对象时，避免为每个类型编写重复的工厂类。
实现：通过泛型接口统一工厂方法，结合反射动态实例化对象。

public interface GenericFactory<T> {T create();
}// 实现通用工厂（基于反射）
public class ReflectionFactory<T> implements GenericFactory<T> {private Class<T> type;public ReflectionFactory(Class<T> type) {this.type = type;}@Overridepublic T create() {try {return type.getDeclaredConstructor().newInstance();} catch (Exception e) {throw new RuntimeException(e);}}
}// 使用示例
public class Main {public static void main(String[] args) {GenericFactory<String> stringFactory = new ReflectionFactory<>(String.class);String str = stringFactory.create();  // 创建空字符串GenericFactory<ArrayList<?>> listFactory = new ReflectionFactory<>(ArrayList.class);ArrayList<?> list = listFactory.create(); // 创建空列表}
}

public interface GenericFactory<T> {T create();
}// 具体产品工厂实现
public class ProductFactory<T extends Product> implements GenericFactory<T> {private Class<T> productClass;public ProductFactory(Class<T> productClass) {this.productClass = productClass;}@Overridepublic T create() {try {return productClass.newInstance();} catch (Exception e) {throw new RuntimeException("创建产品失败", e);}}
}

优势：

一个工厂类支持所有类型，减少代码冗余。
通过类型参数约束，确保工厂产出对象类型正确。

三、策略模式 + 泛型（Generic Strategy）

场景：定义可复用的算法策略，支持不同类型数据的处理逻辑。
实现：泛型接口声明策略，具体实现类处理特定类型。

// 策略接口（泛型化）
public interface ValidationStrategy<T> {boolean validate(T data);
}// 具体策略：校验字符串非空
public class StringNonEmptyStrategy implements ValidationStrategy<String> {@Overridepublic boolean validate(String data) {return data != null && !data.isEmpty();}
}// 具体策略：校验数值范围
public class NumberRangeStrategy implements ValidationStrategy<Integer> {private final int min;private final int max;public NumberRangeStrategy(int min, int max) {this.min = min;this.max = max;}@Overridepublic boolean validate(Integer data) {return data >= min && data <= max;}
}// 使用示例
public class Validator {public static <T> boolean validate(T data, ValidationStrategy<T> strategy) {return strategy.validate(data);}public static void main(String[] args) {boolean isValidString = validate("test", new StringNonEmptyStrategy()); // trueboolean isValidNumber = validate(15, new NumberRangeStrategy(10, 20)); // true}
}

public interface PricingStrategy<T extends Product> {BigDecimal calculatePrice(T product, int quantity);
}// 具体策略实现
public class DiscountPricingStrategy<T extends DiscountableProduct> implements PricingStrategy<T> {@Overridepublic BigDecimal calculatePrice(T product, int quantity) {return product.getOriginalPrice().multiply(product.getDiscountRate()).multiply(new BigDecimal(quantity));}
}

优势：

策略逻辑与数据类型解耦，可复用性强。
编译器检查策略与数据类型的匹配，避免运行时错误。

四、构建器模式 + 泛型（Generic Builder）

场景：构建复杂对象时，支持链式调用和类型安全的属性赋值。
实现：使用泛型递归定义构建器，确保方法链的连贯性。

public abstract class Animal {private final String name;private final int age;protected Animal(Builder<?> builder) {this.name = builder.name;this.age = builder.age;}// 泛型构建器（递归类型定义）public abstract static class Builder<T extends Builder<T>> {private String name;private int age;public T name(String name) {this.name = name;return self();}public T age(int age) {this.age = age;return self();}abstract Animal build();protected abstract T self(); // 返回当前构建器实例}
}// 具体子类：Dog
public class Dog extends Animal {private final String breed;private Dog(DogBuilder builder) {super(builder);this.breed = builder.breed;}// 具体构建器public static class DogBuilder extends Builder<DogBuilder> {private String breed;public DogBuilder breed(String breed) {this.breed = breed;return this;}@Overridepublic Dog build() {return new Dog(this);}@Overrideprotected DogBuilder self() {return this;}}
}// 使用示例
Dog dog = new Dog.DogBuilder().name("Buddy").age(3).breed("Golden Retriever").build();

public class ProductBuilder<T extends Product> {private T product;public ProductBuilder(Supplier<T> supplier) {this.product = supplier.get();}public ProductBuilder<T> withName(String name) {product.setName(name);return this;}public ProductBuilder<T> withPrice(BigDecimal price) {product.setPrice(price);return this;}public T build() {return product;}
}

优势：

链式调用语法清晰，IDE自动补全支持良好。
子类构建器方法返回具体类型，避免类型转换。

五、模板方法模式 + 泛型（Generic Template Method）

场景：定义算法骨架，允许子类实现特定步骤，同时支持不同类型的数据处理。
实现：抽象类使用泛型定义算法流程，子类指定具体类型。

public abstract class DataProcessor<T> {// 模板方法（算法骨架）public final void process() {T data = loadData();validate(data);transform(data);save(data);}protected abstract T loadData();protected abstract void validate(T data);protected abstract void transform(T data);protected abstract void save(T data);
}// 具体实现：处理CSV数据
public class CsvProcessor extends DataProcessor<List<String[]>> {@Overrideprotected List<String[]> loadData() {// 从文件加载CSV数据return Arrays.asList(new String[]{"Alice", "30"}, new String[]{"Bob", "25"});}@Overrideprotected void validate(List<String[]> data) {data.forEach(row -> {if (row.length != 2) throw new IllegalArgumentException("Invalid CSV format");});}@Overrideprotected void transform(List<String[]> data) {data.replaceAll(row -> new String[]{row[0].toUpperCase(), row[1]});}@Overrideprotected void save(List<String[]> data) {System.out.println("Saving processed CSV: " + data);}
}

public abstract class DataProcessor<T, R> {public final R process(T input) {validate(input);R result = doProcess(input);postProcess(result);return result;}protected abstract R doProcess(T input);protected void validate(T input) {// 默认验证逻辑}protected void postProcess(R result) {// 默认后处理逻辑}
}

优势：

复用算法流程，子类只需关注具体类型逻辑。
类型参数明确每个步骤的数据类型，减少错误。

六、责任链模式 + 泛型

线性处理流程

场景：- 电商订单处理流程 ：订单验证→库存检查→支付处理→物流分配
- 审批工作流 ：不同级别的审批人处理不同类型的申请
- 数据处理管道 ：数据清洗→转换→验证→持久化
实现：定义抽象类中下一次调用参数next, 调用时实现链路调用

// 基础订单处理器
public abstract class OrderProcessor<T extends Order> {private OrderProcessor<T> next;public OrderProcessor<T> linkWith(OrderProcessor<T> next) {this.next = next;return next;}public abstract boolean process(T order);protected boolean processNext(T order) {return next == null ? true : next.process(order);}
}// 具体处理器实现
public class InventoryChecker extends OrderProcessor<PurchaseOrder> {@Overridepublic boolean process(PurchaseOrder order) {if (!checkInventory(order)) {return false;}return processNext(order);}private boolean checkInventory(PurchaseOrder order) {// 库存检查逻辑}
}

public interface OrderHandler<T extends Order> {void handle(T order);void setNext(OrderHandler<T> next);
}// 基础抽象类
public abstract class AbstractOrderHandler<T extends Order> implements OrderHandler<T> {private OrderHandler<T> next;@Overridepublic void setNext(OrderHandler<T> next) {this.next = next;}protected void handleNext(T order) {if (next != null) {next.handle(order);}}
}

// 电商订单处理系统（责任链）
// 构建处理链
OrderProcessor<Order> processorChain = new OrderValidator().linkWith(new PaymentProcessor()).linkWith(new ShippingProcessor());// 处理订单
processorChain.process(order);

优势：

类型安全 ：确保每个处理器只处理特定类型的订单
灵活扩展 ：可动态添加新的处理器而不影响现有逻辑
解耦：每个处理器只需关注自己的职责范围

注意：处理链中所有处理器类型一致、链长度影响性能、单向传递

七、观察者模式 + 泛型

事件通知场景

场景：- 电商事件通知 ：订单状态变更、库存预警、支付成功等事件
- 用户行为追踪：记录用户浏览、点击、购买等行为
- 系统监控：CPU使用率、内存占用等指标变化通知
实现：抽象类使用泛型定义算法流程，子类指定具体类型。

public class GenericEventBus<T> {private Map<Class<? extends T>, List<Consumer<? extends T>>> listeners = new ConcurrentHashMap<>();public <E extends T> void subscribe(Class<E> eventType, Consumer<E> listener) {listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(listener);}@SuppressWarnings("unchecked")public <E extends T> void publish(E event) {List<Consumer<? extends T>> eventListeners = listeners.get(event.getClass());if (eventListeners != null) {eventListeners.forEach(listener -> ((Consumer<E>) listener).accept(event));}}
}// 事件定义
public class OrderEvent {private String orderId;// 其他字段...
}

public class EventPublisher<T> {private List<Consumer<T>> listeners = new ArrayList<>();public void subscribe(Consumer<T> listener) {listeners.add(listener);}public void publish(T event) {listeners.forEach(listener -> listener.accept(event));}
}

//  库存预警系统（观察者）
// 创建事件总线
GenericEventBus<InventoryEvent> eventBus = new GenericEventBus<>();// 订阅事件
eventBus.subscribe(LowStockEvent.class, event -> {// 发送预警邮件emailService.sendLowStockAlert(event.getProductId());
});// 发布事件
eventBus.publish(new LowStockEvent(productId, currentStock));

优势：

类型精确匹配：订阅者只会收到其订阅的特定类型事件
性能优化：通过事件类型分类，减少不必要的通知
编译时检查：避免运行时类型转换错误
多事件类型支持：一个事件总线可处理多种相关事件类型

注意：订阅者数量影响性能、可处理多种相关事件类型、发布者无法控制订阅者执行、一对多广播