Flutter模板方法模式在多Tab列表中的应用 项目背景与需求在Flutter开发中，我们经常遇到需要实现多Tab栏列表的场景，每个Tab具有相似的结构（下拉刷新、上拉加载、列表展示），但数据类型和UI展示各不相同。本文将介绍如何使用模板方法模式来优雅地解决这个问题。模板方法模式简介模板方法模式是一种行为设计模式，它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写特定步骤。在我们的场景中，每个Tab的加载流程（初始化→刷新→加载更多）是相同的，但具体的数据加载和UI展示是不同的。代码实现解析1. 抽象基类定义const int defaultPageSize = 10; abstract class TabData<T> { final String name; // tab名称 int total; // 数据数量 bool isSelected; // 选中状态 bool hasMore; // 是否有更多数据 List<T> items; // 数据列表 bool _isInited = false; // 是否初始化完成 final RefreshController controller; final Widget Function(BuildContext context,T item) itemBuilder; TabData({ required this.name, required this.itemBuilder, this.total = 0, this.isSelected = false, this.hasMore = true, this.items = const [] }) : controller = RefreshController(); int get pageSize => defaultPageSize; Future<List<T>> loadData(int page); void updateItems(List<T> newItems, bool isRefresh); Future<bool> init() async{ if (_isInited) { return true; } _isInited = true; await onRefresh(); return false; } Future<void> onRefresh() async { try { final data = await loadData(1); updateItems(data, true); hasMore = data.length >= pageSize; controller.refreshCompleted(); } catch (e) { controller.refreshFailed(); rethrow; } } Future<void> onLoadMore() async { if (!hasMore) { controller.loadNoData(); return; } try { final currentPage = (items.length / pageSize).ceil() + 1; final data = await loadData(currentPage); updateItems(data, false); hasMore = data.length >= pageSize; controller.loadComplete(); } catch (e) { controller.refreshFailed(); rethrow; } } void dispose() { controller.dispose(); } }设计要点：定义了完整的生命周期方法（init、onRefresh、onLoadMore）使用泛型T支持不同的数据类型封装了刷新控制器和分页逻辑提供itemBuilder回调实现UI定制化2. 具体子类实现点赞Tab实现：class LikeTabData extends TabData<LikeTabDataEntity>{ LikeTabData():super(name: "点赞",itemBuilder: (context,item){ return Text(item.name); }); @override Future<List<LikeTabDataEntity>> loadData(int page) async{ await Future.delayed(const Duration(seconds: 1)); return List.generate(pageSize, (index)=> LikeTabDataEntity(name: "$name 数据 ${page * pageSize + index}")); } @override void updateItems(List<LikeTabDataEntity> newItems, bool isRefresh) { items = isRefresh ? newItems : [...items, ...newItems]; total = items.length; } }评论Tab实现：class CommentTabData extends TabData<CommentTabDataEntity>{ CommentTabData():super(name: "评论",itemBuilder: (context,item) { Widget text () => Text(item.text,style: const TextStyle(color: Colors.white)); return Container( margin: const EdgeInsets.all(8), padding: const EdgeInsets.all(10), decoration: BoxDecoration( color: Colors.blueAccent, borderRadius: BorderRadius.circular(8), ), child: text(), ); }); @override Future<List<CommentTabDataEntity>> loadData(int page) async{ await Future.delayed(const Duration(seconds: 1)); return List.generate(pageSize, (index)=> CommentTabDataEntity(text: "$name 数据 ${page * pageSize + index}")); } @override void updateItems(List<CommentTabDataEntity> newItems, bool isRefresh) { items = isRefresh ? newItems : [...items, ...newItems]; total = items.length; } }子类只需实现：loadData：具体的数据加载逻辑updateItems：数据合并策略itemBuilder：列表项UI构建3. 状态管理class DialogState extends BaseViewState { List<TabData> tabDataList = [ LikeTabData(), CommentTabData(), LikeTabData(), CommentTabData(), ]; }4. 逻辑控制器class DialogLogic extends BaseGetXLifeCycleController{ late final PageController tabController; final state = DialogState(); @override void onInit() { super.onInit(); tabController = PageController(); state.viewState = TYPE_LOAD; update(); state.tabDataList.first.init().then((_)=> update()); Future.delayed(const Duration(seconds: 1),(){ state.tabDataList.first.isSelected = true; state.viewState = TYPE_NORMAL; update(); }); } @override void onClose() { tabController.dispose(); for(final item in state.tabDataList) { item.dispose(); } super.onClose(); } void onTabChange(int index) async{ for(int i = 0; i < state.tabDataList.length; i++) { state.tabDataList[i].isSelected = index == i; } update(); final isInited = await state.tabDataList[index].init(); if(!isInited) update(); } void changeTab(int index,BuildContext context){ final screenWidth = MediaQuery.of(context).size.width; tabController.animateTo(index * screenWidth,duration: const Duration(milliseconds: 300), curve: Curves.easeInOut); } void onRefresh(Future<void> Function() refresh) async{ await refresh(); update(); } void onLoadMore(Future<void> Function() loadMore) async{ await loadMore(); update(); } }5. UI界面实现class Dialog extends BaseTitleBottomSheet with GetXControllerMixin<DialogLogic>{ Dialog({super.key}); final logic = Get.put(DialogLogic()); final state = Get.find<DialogLogic>().state; @override String getTitle() => "Dialog"; @override Widget buildContent() { return buildPartBaseView( state.viewState,context, _buildContentWidget() ); } Widget _buildContentWidget() { return Expanded( child: Column( children: [ SingleChildScrollView( child: Row( mainAxisAlignment: MainAxisAlignment.spaceEvenly, children: [ for(int i = 0;i<state.tabDataList.length;i++) GestureDetector(onTap: ()=> logic.changeTab(i,context),child: _buildTabWidget(state.tabDataList[i])) ], ), ), Expanded( child: PageView.builder( controller: logic.tabController, onPageChanged: logic.onTabChange, itemCount: state.tabDataList.length, itemBuilder: (_,index){ final data = state.tabDataList[index]; if(data.items.isEmpty){ return const Center(child: Text("无数据"),); } return _KeepAliveList( data, keepAlive: true, onLoading: ()=> logic.onLoadMore(data.onLoadMore), onRefresh: ()=> logic.onRefresh(data.onRefresh), controller: data.controller ); }, ), ), ], ), ); } Widget _buildTabWidget(TabData entity){ final noSelectedStyle = TextStyle(color: Colors.black,fontSize: 23.w); final selectedStyle = TextStyle(color: Colors.blueAccent,fontSize: 23.w); final style = entity.isSelected ? selectedStyle : noSelectedStyle; return Row( mainAxisSize: MainAxisSize.min, children: [ Text(entity.name,style: style), Text("（${entity.total}）",style: style), ], ); } } class _KeepAliveList extends StatefulWidget { final TabData tabData; final bool keepAlive; final VoidCallback? onRefresh; final VoidCallback? onLoading; final RefreshController controller; const _KeepAliveList(this.tabData,{super.key,this.keepAlive = true,required this.controller,this.onRefresh,this.onLoading}); @override State<_KeepAliveList> createState() => _KeepAliveListState(); } class _KeepAliveListState extends State<_KeepAliveList> with AutomaticKeepAliveClientMixin{ @override Widget build(BuildContext context) { super.build(context); return SmartRefresher( controller: widget.controller, enablePullDown: true, enablePullUp: true, header: const ClassicHeader(), onRefresh: widget.onRefresh, onLoading: widget.onLoading, child: ListView.builder( itemCount: widget.tabData.items.length, itemBuilder: (context,index){ // 新版本dart可以使用switch匹配模式，可以穷举完全部密封类的子类 // 为了兼容只能使用if了 final tabData = widget.tabData; if(tabData is LikeTabData){ return tabData.itemBuilder(context,tabData.items[index]); }else if(tabData is CommentTabData){ return tabData.itemBuilder(context,tabData.items[index]); } throw "未知的TabData类型"; }, ), ); } @override bool get wantKeepAlive => widget.keepAlive; }设计优势1. 代码复用性公共的刷新、加载、分页逻辑在基类中实现新增Tab只需继承TabData并实现三个抽象方法2. 可维护性算法框架稳定，修改基类即可影响所有子类业务逻辑与UI展示分离3. 扩展性支持任意类型的列表数据可轻松添加新的Tab类型4. 一致性所有Tab保持相同的交互逻辑统一的错误处理和加载状态使用建议添加新Tab：只需创建新的TabData子类，实现loadData、updateItems和itemBuilder修改公共逻辑：在TabData基类中修改，所有子类自动生效自定义分页大小：在子类中重写pageSize getter特殊处理：子类可重写onRefresh或onLoadMore方法进行个性化处理总结通过模板方法模式，我们成功地将多Tab列表中的公共逻辑提取到基类中，同时保留了子类的灵活性。这种设计模式特别适用于具有相似流程但不同实现的场景，能够显著减少代码重复，提高项目的可维护性和扩展性。

Java 设计模式之享元模式详解 1. 定义享元模式（Flyweight Pattern）是一种结构型设计模式，其核心思想是通过共享对象来减少内存的使用和提高系统性能。享元模式通过将内部可共享的状态和外部独立的状态分离，从而减少对象的重复创建。2. 适用场景享元模式适用于以下情况：对象数量庞大，且大多数对象可以共享部分状态。内存消耗高，有必要通过对象复用来优化性能。外部状态可独立存储，共享的对象可以被多个外部对象同时使用。3. 模式结构享元模式主要由以下几个部分构成：Flyweight接口：定义享元对象的接口，包含需要实现的业务方法。ConcreteFlyweight（具体享元类）：实现 Flyweight 接口，提供共享的内部状态。UnsharedConcreteFlyweight（非共享享元类）：定义那些不被共享的对象。FlyweightFactory（享元工厂类）：用于管理享元对象，提供共享对象的缓存机制。Client（客户端）：负责存储和操作外部状态，并使用享元对象完成具体任务。4. 享元模式的核心：内部状态与外部状态内部状态：可以共享的部分，不会随外部变化。由享元对象内部维护。外部状态：不可共享的部分，会随环境改变。由客户端维护或传递给享元对象。5. 实例：JDK 中 Integer 的缓存机制在 Java 中，Integer 类为了提高性能和减少内存消耗，对 -128 到 127 之间的整数进行了缓存，这是享元模式的一个典型应用。5.1 Integer 缓存的工作原理当你对一个 Integer 对象进行自动装箱或通过 Integer.valueOf() 创建时，JVM 会检查数字是否在缓存范围（-128 到 127）内：如果在此范围内，返回缓存中的对象。如果超出该范围，创建新的 Integer 对象。Integer i1 = 127; // 自动装箱，相当于 Integer.valueOf(127) Integer i2 = 127; // 直接从缓存中获取 Integer i3 = 128; // 创建新的对象，因为超出缓存范围 Integer i4 = 128; // 再次创建新的对象5.2 Integer 缓存的源码Integer.valueOf() 方法通过内部的 IntegerCache 类来实现缓存机制：public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) { return IntegerCache.cache[i + (-IntegerCache.low)]; } return new Integer(i); } private static class IntegerCache { static final int low = -128; static final int high = 127; static final Integer cache[]; static { cache = new Integer[(high - low) + 1]; for (int i = 0, j = low; j <= high; i++, j++) { cache[i] = new Integer(j); } } }在此代码中，IntegerCache 类缓存了 -128 到 127 之间的 Integer 对象。调用 Integer.valueOf() 时，如果数字在缓存范围内，则返回缓存对象，避免创建新的对象。5.3 实例演示public class FlyweightExample { public static void main(String[] args) { Integer i1 = Integer.valueOf(127); Integer i2 = Integer.valueOf(127); Integer i3 = Integer.valueOf(128); Integer i4 = Integer.valueOf(128); System.out.println(i1 == i2); // true, 127在缓存范围内，共享对象 System.out.println(i3 == i4); // false, 128不在缓存范围内，不同对象 } }输出结果：true false5.4 内部状态与外部状态的应用内部状态：在 -128 到 127 之间的整数是共享的，表示可重复使用的部分（享元模式中的共享对象）。外部状态：超出此范围的整数需要每次新建，是不可共享的部分。6. 享元模式总结优点：减少内存开销：通过共享相同的对象，减少了重复对象的创建，尤其在大量小对象场景中非常有效。提高性能：减少了对象的创建和销毁过程，尤其在大量使用相似对象时性能提升显著。缺点：增加代码复杂度：需要区分内部状态和外部状态，额外的状态管理会增加代码复杂度。适用场景有限：仅在对象可共享且变化不大时效果显著，不适用于复杂对象或场景。7. 适用案例JDK 中 Integer 的缓存机制：Integer 类缓存了 -128 到 127 之间的整数，避免重复创建相同数值的对象，节省内存。文本编辑器中的字符对象：同样字符的对象可以共享字体、大小等属性，只需根据不同位置设定外部状态（坐标）。游戏中的精灵对象：相同的精灵图片资源可以共享，不同精灵的位置和行为通过外部状态来控制。8. 模式应用要点享元模式的核心是通过分离共享的内部状态和不可共享的外部状态来实现对象的重用。在实际开发中，常见的场景如缓存、池化资源管理等，都可以通过享元模式来实现内存优化。

封装和抽象 Java 的构建者模式 创建一个通用的 Builder 接口或抽象类，并将具体的构建过程委托给子类或具体实现类。这样做可以复用构建逻辑，并且提高代码的可扩展性和维护性。1. 抽象 Builder 类首先，我们可以定义一个抽象的 Builder 类，这个类会定义一个通用的构建流程，并且要求子类去实现具体的构建步骤。public abstract class Builder<T> { protected T instance; // 提供创建对象的通用方法 protected abstract T createInstance(); // 每个具体的构建步骤由子类实现 public Builder<T> with(Consumer<T> setter) { setter.accept(instance); return this; } // 返回最终构建的对象 public T build() { return instance; } }2. 具体实现 UserBuilder继承上面的抽象 Builder 类，针对具体的 User 对象，我们可以实现一个 UserBuilder：public class User { private String firstName; private String lastName; private int age; private String phone; private String address; // 公开构造函数或私有构造函数 public User() { } // getter和setter public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } } public class UserBuilder extends Builder<User> { @Override protected User createInstance() { return new User(); } public UserBuilder() { this.instance = createInstance(); } public UserBuilder firstName(String firstName) { return this.with(user -> user.setFirstName(firstName)); } public UserBuilder lastName(String lastName) { return this.with(user -> user.setLastName(lastName)); } public UserBuilder age(int age) { return this.with(user -> user.setAge(age)); } public UserBuilder phone(String phone) { return this.with(user -> user.setPhone(phone)); } public UserBuilder address(String address) { return this.with(user -> user.setAddress(address)); } }3. 使用方式使用抽象后的 Builder 类构建 User 对象：public class Main { public static void main(String[] args) { User user = new UserBuilder() .firstName("John") .lastName("Doe") .age(30) .phone("123456789") .address("123 Main St") .build(); System.out.println(user.getFirstName()); System.out.println(user.getLastName()); System.out.println(user.getAge()); System.out.println(user.getPhone()); System.out.println(user.getAddress()); } }4. 优势通过这种方式：通用性：Builder 类可以复用，也可以通过创建不同的具体构建器（如 UserBuilder）来构建不同的对象。可扩展性：如果以后有其他复杂对象需要使用构建者模式，只需要继承 Builder 类，提供具体的实现即可。简化构建流程：with 方法的引入使得构建过程更加简洁和灵活。这个模式让你的代码不仅易于维护，而且能很好地应对未来的扩展需求。