泛型設計模式實踐

學海無涯，志當存遠。燃心礪志，奮進不輟。

愿諸君得此雞湯，如沐春風，事業有成。

若覺此言甚善，煩請賜贊一枚，共勵學途，同鑄輝煌！

為解決在設計框架或庫時遇到的類型安全問題，或者處理多態集合時的挑戰。
希望優化代碼結構，減少重復，提高類型安全。
需要結合常見的設計模式，比如工廠模式、策略模式等，展示泛型如何在這些模式中發揮作用。常見的泛型設計模式，比如類型安全的異構容器、泛型單例工廠、策略模式中的泛型應用，以及構建器模式。
需要具體說明每個模式的應用場景、實現方式和優勢。
例如，類型安全的異構容器使用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));

優勢：

類型精確匹配：訂閱者只會收到其訂閱的特定類型事件
性能優化：通過事件類型分類，減少不必要的通知
編譯時檢查：避免運行時類型轉換錯誤
多事件類型支持：一個事件總線可處理多種相關事件類型

注意：訂閱者數量影響性能、可處理多種相關事件類型、發布者無法控制訂閱者執行、一對多廣播