1. 状态管理基础

1.1 什么是状态

在Flutter中，状态(State)指的是应用在特定时间点的数据快照。这些数据可能包括：

• 用户数据（如个人资料、设置偏好）
• 应用数据（如产品列表、购物车内容）
• UI状态（如加载状态、表单验证、按钮启用/禁用）
• 导航状态（如当前页面、导航历史）

状态可以分为两种主要类型：

1. 短暂状态(Ephemeral State)：也称为UI状态或局部状态，仅影响单个widget
2. 应用状态(App State)：跨多个widget共享的状态，影响应用的多个部分

1.2 为什么需要状态管理

随着应用复杂性增加，出现了以下挑战：

• 状态分散在应用的不同部分
• 组件间需要共享状态
• 需要在组件树不同层级访问状态
• 状态变化需要反映到UI上
• 确保状态一致性和可预测性

良好的状态管理解决方案应该：

• 使状态变化可预测
• 减少组件之间的耦合
• 提高代码可测试性
• 使应用更易于维护和扩展

2. Flutter中的状态管理方案

2.1 setState (基础方案)

最简单的状态管理方式，适用于管理局部UI状态。

基本用法

class CounterWidget extends StatefulWidget {
  @override
  _CounterWidgetState createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  int _counter = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text('计数: $_counter'),
        ElevatedButton(
          onPressed: _incrementCounter,
          child: Text('增加'),
        )
      ],
    );
  }
}

优缺点

优点

• 简单直观，是Flutter内置的解决方案
• 不需要额外的包依赖
• 适合简单的UI状态管理

缺点

• 不适合跨widget共享状态
• 可能导致widget重建过多（性能问题）
• 在复杂应用中会导致代码难以维护

2.2 InheritedWidget

Flutter提供的用于向下传递数据的内置机制，是许多高级状态管理方案的基础。

基本用法

class CounterModel extends InheritedWidget {
  final int counter;
  final Function incrementCounter;

  CounterModel({
    required this.counter,
    required this.incrementCounter,
    required Widget child,
  }) : super(child: child);

  static CounterModel of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<CounterModel>()!;
  }

  @override
  bool updateShouldNotify(CounterModel oldWidget) {
    return counter != oldWidget.counter;
  }
}

class CounterProvider extends StatefulWidget {
  final Widget child;
  
  CounterProvider({required this.child});
  
  @override
  _CounterProviderState createState() => _CounterProviderState();
}

class _CounterProviderState extends State<CounterProvider> {
  int _counter = 0;
  
  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return CounterModel(
      counter: _counter,
      incrementCounter: _incrementCounter,
      child: widget.child,
    );
  }
}

// 使用
class CounterScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final counterModel = CounterModel.of(context);
    return Column(
      children: [
        Text('计数: ${counterModel.counter}'),
        ElevatedButton(
          onPressed: () => counterModel.incrementCounter(),
          child: Text('增加'),
        ),
      ],
    );
  }
}

优缺点

优点

• Flutter核心机制，无需额外依赖
• 提供从上到下的数据流
• 当数据变化时自动重建依赖的widgets

缺点

• 需要大量样板代码
• 组合多个InheritedWidget比较困难
• 不提供状态管理，只提供数据传递

2.3 Provider

在InheritedWidget基础上构建的状态管理库，是Flutter团队推荐的方案之一。

基本用法

// 1. 定义数据模型
class CounterModel extends ChangeNotifier {
  int _count = 0;
  
  int get count => _count;
  
  void increment() {
    _count++;
    notifyListeners();
  }
}

// 2. 提供状态
void main() {
  runApp(
    ChangeNotifierProvider(
      create: (context) => CounterModel(),
      child: MyApp(),
    ),
  );
}

// 3. 消费状态
class CounterDisplay extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // 方式1：使用Consumer
    return Consumer<CounterModel>(
      builder: (context, counter, child) {
        return Text('计数: ${counter.count}');
      },
    );
  }
}

class CounterIncrement extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // 方式2：使用Provider.of
    return ElevatedButton(
      onPressed: () {
        Provider.of<CounterModel>(context, listen: false).increment();
      },
      child: Text('增加'),
    );
  }
}

// 多个Provider嵌套
void main() {
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (context) => CounterModel()),
        ChangeNotifierProvider(create: (context) => UserModel()),
        Provider(create: (context) => SomeService()),
      ],
      child: MyApp(),
    ),
  );
}

Provider的变体

• Provider: 基本的Provider，不会在值变化时重建widget
• ChangeNotifierProvider: 监听ChangeNotifier，当notifyListeners()被调用时重建widget
• FutureProvider: 提供Future的结果
• StreamProvider: 提供Stream的最新值
• ListenableProvider: 监听Listenable对象，适用于不是ChangeNotifier的情况
• ValueListenableProvider: 专门用于ValueListenable

优缺点

优点

• 易于学习和使用
• 良好的性能（精确控制重建）
• 与Flutter很好地集成
• 支持依赖注入
• 丰富的文档和社区支持
• 由Flutter团队推荐

缺点

• 复杂应用中可能需要创建大量模型类
• 处理深层次嵌套状态需要精心设计
• 状态模型之间的依赖需要手动管理

2.4 Riverpod

Provider的进化版，解决了Provider的一些限制。

基本用法

// 1. 定义Provider
final counterProvider = StateNotifierProvider<CounterNotifier, int>((ref) {
  return CounterNotifier();
});

class CounterNotifier extends StateNotifier<int> {
  CounterNotifier() : super(0);
  
  void increment() => state = state + 1;
}

// 2. 在应用顶层使用ProviderScope
void main() {
  runApp(
    ProviderScope(
      child: MyApp(),
    ),
  );
}

// 3. 使用状态
class CounterDisplay extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final count = ref.watch(counterProvider);
    return Text('计数: $count');
  }
}

class CounterIncrement extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return ElevatedButton(
      onPressed: () {
        ref.read(counterProvider.notifier).increment();
      },
      child: Text('增加'),
    );
  }
}

Riverpod的特点

• 完全类型安全，没有运行时错误
• 不需要上下文(context)来访问providers
• 可以在任何地方（甚至在initState外部）访问providers
• 支持自动释放未使用的状态
• 轻松处理异步状态
• 简化测试

优缺点

优点

• 解决了Provider的上下文依赖问题
• 提供真正的类型安全
• 更好的异步状态处理
• 简化代码复用

缺点

• 学习曲线稍陡
• 与Flutter不同的语法（ref vs context）
• 需要特殊widget（ConsumerWidget等）

2.5 BLoC/Cubit

基于流(Stream)的状态管理方案，将业务逻辑与UI分离。

Cubit (简化的BLoC)

// 1. 定义状态
class CounterState {
  final int count;
  
  CounterState(this.count);
}

// 2. 创建Cubit
class CounterCubit extends Cubit<CounterState> {
  CounterCubit() : super(CounterState(0));
  
  void increment() {
    emit(CounterState(state.count + 1));
  }
}

// 3. 提供Cubit
void main() {
  runApp(
    BlocProvider(
      create: (context) => CounterCubit(),
      child: MyApp(),
    ),
  );
}

// 4. 使用状态
class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: BlocBuilder<CounterCubit, CounterState>(
        builder: (context, state) {
          return Text('计数: ${state.count}');
        },
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => context.read<CounterCubit>().increment(),
        child: Icon(Icons.add),
      ),
    );
  }
}

BLoC (完整版)

// 1. 定义事件
abstract class CounterEvent {}
class IncrementEvent extends CounterEvent {}

// 2. 创建BLoC
class CounterBloc extends Bloc<CounterEvent, CounterState> {
  CounterBloc() : super(CounterState(0)) {
    on<IncrementEvent>((event, emit) {
      emit(CounterState(state.count + 1));
    });
  }
}

// 3. 提供BLoC
void main() {
  runApp(
    BlocProvider(
      create: (context) => CounterBloc(),
      child: MyApp(),
    ),
  );
}

// 4. 使用状态
class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: BlocBuilder<CounterBloc, CounterState>(
        builder: (context, state) {
          return Text('计数: ${state.count}');
        },
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => context.read<CounterBloc>().add(IncrementEvent()),
        child: Icon(Icons.add),
      ),
    );
  }
}

优缺点

优点

• 状态、事件和业务逻辑的强分离
• 高度可测试性
• 反应式编程方式
• 复杂状态转换的良好处理

缺点

• 较陡峭的学习曲线
• 增加了大量样板代码
• 小型应用中可能过于复杂

2.6 Redux

基于单向数据流的状态管理方案，源自Web开发。

基本用法

// 1. 定义应用状态
class AppState {
  final int counter;
  
  AppState({this.counter = 0});
  
  AppState copyWith({int? counter}) {
    return AppState(
      counter: counter ?? this.counter,
    );
  }
}

// 2. 定义Action
class IncrementAction {}

// 3. 创建Reducer
AppState reducer(AppState state, dynamic action) {
  if (action is IncrementAction) {
    return state.copyWith(counter: state.counter + 1);
  }
  return state;
}

// 4. 创建Store
final store = Store<AppState>(
  reducer,
  initialState: AppState(),
);

// 5. 提供Store
void main() {
  runApp(
    StoreProvider<AppState>(
      store: store,
      child: MyApp(),
    ),
  );
}

// 6. 使用状态
class CounterDisplay extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StoreConnector<AppState, int>(
      converter: (store) => store.state.counter,
      builder: (context, counter) {
        return Text('计数: $counter');
      },
    );
  }
}

class CounterIncrement extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StoreConnector<AppState, VoidCallback>(
      converter: (store) {
        return () => store.dispatch(IncrementAction());
      },
      builder: (context, callback) {
        return ElevatedButton(
          onPressed: callback,
          child: Text('增加'),
        );
      },
    );
  }
}

优缺点

优点

• 可预测的单向数据流
• 集中式状态管理
• 良好的调试能力（时间旅行调试）
• 中间件支持（处理副作用）

缺点

• 大量样板代码
• 较陡峭的学习曲线
• 简单操作需要多处修改

2.7 GetX

轻量级且功能强大的状态管理、路由管理和依赖注入解决方案。

基本用法

// 1. 定义控制器
class CounterController extends GetxController {
  var count = 0.obs;  // 使用.obs创建可观察变量
  
  void increment() {
    count++;  // 自动更新UI
  }
}

// 2. 初始化
void main() {
  runApp(
    GetMaterialApp(  // 替换MaterialApp
      home: Home(),
    ),
  );
}

// 3. 使用状态 - 方式1：GetX
class CounterDisplay1 extends StatelessWidget {
  final controller = Get.put(CounterController());  // 注入控制器
  
  @override
  Widget build(BuildContext context) {
    return GetX<CounterController>(
      builder: (controller) {
        return Text('计数: ${controller.count.value}');
      },
    );
  }
}

// 3. 使用状态 - 方式2：Obx（更简洁）
class CounterDisplay2 extends StatelessWidget {
  final controller = Get.find<CounterController>();  // 查找已注入的控制器
  
  @override
  Widget build(BuildContext context) {
    return Obx(() => Text('计数: ${controller.count.value}'));
  }
}

// 4. 更新状态
class CounterIncrement extends StatelessWidget {
  final controller = Get.find<CounterController>();
  
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: controller.increment,
      child: Text('增加'),
    );
  }
}

优缺点

优点

• 简单易用，API简洁
• 整合路由管理、依赖注入和状态管理
• 高性能（只重建需要的widgets）
• 不需要上下文(context)
• 低样板代码量

缺点

• 非标准Flutter方法
• 社区支持不如主流方案
• 架构可能导致滥用全局状态

2.8 MobX

基于可观察对象的状态管理库，源自React生态系统。

基本用法

// 1. 定义Store
part 'counter_store.g.dart';  // 代码生成部分

class CounterStore = _CounterStore with _$CounterStore;

abstract class _CounterStore with Store {
  @observable
  int count = 0;
  
  @computed
  bool get isEven => count % 2 == 0;
  
  @action
  void increment() {
    count++;
  }
}

// 2. 创建和提供Store
final counterStore = CounterStore();

// 3. 使用Store
class CounterDisplay extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Observer(
      builder: (_) => Column(
        children: [
          Text('计数: ${counterStore.count}'),
          Text('是偶数: ${counterStore.isEven ? "是" : "否"}'),
        ],
      ),
    );
  }
}

class CounterIncrement extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: counterStore.increment,
      child: Text('增加'),
    );
  }
}

优缺点

优点

• 基于可观察模式，精确更新
• 计算属性支持
• 响应式编程体验
• 与React MobX相似（熟悉React的开发者易上手）

缺点

• 需要代码生成
• 需要特殊装饰器处理
• 学习曲线中等

3. 状态管理方案比较

3.1 功能比较

3.2 适用场景

• setState: 简单的组件内状态管理，原型开发
• Provider: 中小型应用，需要共享状态但不复杂
• Riverpod: 需要更好类型安全和依赖管理的应用
• BLoC/Cubit: 大型应用，有复杂业务逻辑，团队协作
• Redux: 需要严格状态控制，喜欢函数式编程
• GetX: 需要快速开发，简洁代码，及路由管理
• MobX: 喜欢响应式编程，熟悉MobX从React迁移

4. 状态管理最佳实践

4.1 通用原则

1. 基于复杂度选择工具

   • 简单状态使用简单工具(setState)
   • 不要过早优化或引入复杂框架

2. 状态分层

   • 区分UI状态和业务状态
   • 局部状态使用局部解决方案
   • 全局状态使用全局方案

3. 单一数据源

   • 每个状态应该有一个明确的来源
   • 避免状态重复

4. 不可变状态

   • 不直接修改状态
   • 创建新状态来替换旧状态

5. 最小化重建

   • 只重建依赖变化状态的UI部分
   • 将大型widget拆分为小部件

4.2 代码组织

1. 关注点分离

   • 将UI、业务逻辑和数据访问分开
   • 使用分层架构（UI层、业务层、数据层）

2. 模块化

   • 按功能组织代码，而不是按类型
   • 每个模块包含其UI和状态管理

3. 依赖注入

   • 使用依赖注入降低组件耦合
   • 便于测试和替换实现

4.3 常见反模式

1. 状态过度集中

   • 将所有状态放在一个巨大的类中
   • 导致不必要的重建和性能问题

2. 状态过度分散

   • 没有合理组织相关状态
   • 导致状态管理混乱，难以维护

3. 过早优化

   • 在不需要复杂解决方案时使用它们
   • 增加不必要的学习和开发成本

4. 滥用全局状态

   • 将应该是局部的状态放到全局
   • 导致组件紧密耦合

5. 实际案例

5.1 购物车应用（使用Provider）

// 定义产品模型
class Product {
  final int id;
  final String name;
  final double price;
  
  Product({required this.id, required this.name, required this.price});
}

// 购物车模型
class CartModel extends ChangeNotifier {
  final List<Product> _items = [];
  
  List<Product> get items => List.unmodifiable(_items);
  
  double get totalPrice => 
    _items.fold(0, (sum, product) => sum + product.price);
  
  void add(Product product) {
    _items.add(product);
    notifyListeners();
  }
  
  void removeAt(int index) {
    _items.removeAt(index);
    notifyListeners();
  }
  
  void clear() {
    _items.clear();
    notifyListeners();
  }
}

// 产品目录模型
class CatalogModel extends ChangeNotifier {
  final List<Product> _products = [
    Product(id: 1, name: "商品1", price: 10.0),
    Product(id: 2, name: "商品2", price: 15.0),
    Product(id: 3, name: "商品3", price: 20.0),
  ];
  
  List<Product> get products => List.unmodifiable(_products);
}

// 应用入口
void main() {
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (context) => CatalogModel()),
        ChangeNotifierProvider(create: (context) => CartModel()),
      ],
      child: MyApp(),
    ),
  );
}

// 产品列表页面
class ProductListPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final catalog = Provider.of<CatalogModel>(context);
    final cart = Provider.of<CartModel>(context, listen: false);
    
    return Scaffold(
      appBar: AppBar(
        title: Text('产品列表'),
        actions: [
          IconButton(
            icon: Icon(Icons.shopping_cart),
            onPressed: () {
              Navigator.push(
                context,
                MaterialPageRoute(builder: (context) => CartPage()),
              );
            },
          ),
        ],
      ),
      body: ListView.builder(
        itemCount: catalog.products.length,
        itemBuilder: (context, index) {
          final product = catalog.products[index];
          return ListTile(
            title: Text(product.name),
            subtitle: Text('¥${product.price}'),
            trailing: IconButton(
              icon: Icon(Icons.add_shopping_cart),
              onPressed: () {
                cart.add(product);
                ScaffoldMessenger.of(context).showSnackBar(
                  SnackBar(content: Text('${product.name} 已添加到购物车')),
                );
              },
            ),
          );
        },
      ),
    );
  }
}

// 购物车页面
class CartPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('购物车')),
      body: Consumer<CartModel>(
        builder: (context, cart, child) {
          if (cart.items.isEmpty) {
            return Center(child: Text('购物车为空'));
          }
          
          return Column(
            children: [
              Expanded(
                child: ListView.builder(
                  itemCount: cart.items.length,
                  itemBuilder: (context, index) {
                    final product = cart.items[index];
                    return ListTile(
                      title: Text(product.name),
                      subtitle: Text('¥${product.price}'),
                      trailing: IconButton(
                        icon: Icon(Icons.remove_circle),
                        onPressed: () {
                          cart.removeAt(index);
                        },
                      ),
                    );
                  },
                ),
              ),
              Padding(
                padding: const EdgeInsets.all(16.0),
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.spaceBetween,
                  children: [
                    Text('总计: ¥${cart.totalPrice}', 
                      style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
                    ),
                    ElevatedButton(
                      onPressed: () {
                        // 结账逻辑
                        cart.clear();
                        Navigator.pop(context);
                        ScaffoldMessenger.of(context).showSnackBar(
                          SnackBar(content: Text('订单已完成')),
                        );
                      },
                      child: Text('结账'),
                    ),
                  ],
                ),
              ),
            ],
          );
        },
      ),
    );
  }
}

5.2 认证应用（使用BLoC）

// 认证状态
abstract class AuthState {}
class AuthInitial extends AuthState {}
class AuthLoading extends AuthState {}
class AuthAuthenticated extends AuthState {
  final User user;
  AuthAuthenticated(this.user);
}
class AuthUnauthenticated extends AuthState {
  final String? message;
  AuthUnauthenticated([this.message]);
}

// 认证事件
abstract class AuthEvent {}
class LoginEvent extends AuthEvent {
  final String username;
  final String password;
  LoginEvent(this.username, this.password);
}
class LogoutEvent extends AuthEvent {}

// 用户模型
class User {
  final String id;
  final String name;
  
  User({required this.id, required this.name});
}

// 认证服务
class AuthService {
  Future<User> login(String username, String password) async {
    // 模拟网络请求
    await Future.delayed(Duration(seconds: 2));
    
    if (username == 'admin' && password == 'password') {
      return User(id: '1', name: 'Admin User');
    } else {
      throw Exception('用户名或密码错误');
    }
  }
  
  Future<void> logout() async {
    await Future.delayed(Duration(seconds: 1));
    // 清除令牌等
  }
}

// 认证BLoC
class AuthBloc extends Bloc<AuthEvent, AuthState> {
  final AuthService authService;
  
  AuthBloc(this.authService) : super(AuthInitial()) {
    on<LoginEvent>(_onLogin);
    on<LogoutEvent>(_onLogout);
  }
  
  Future<void> _onLogin(LoginEvent event, Emitter<AuthState> emit) async {
    emit(AuthLoading());
    
    try {
      final user = await authService.login(event.username, event.password);
      emit(AuthAuthenticated(user));
    } catch (e) {
      emit(AuthUnauthenticated(e.toString()));
    }
  }
  
  Future<void> _onLogout(LogoutEvent event, Emitter<AuthState> emit) async {
    emit(AuthLoading());
    
    try {
      await authService.logout();
      emit(AuthUnauthenticated());
    } catch (e) {
      emit(AuthUnauthenticated(e.toString()));
    }
  }
}

// 应用入口
void main() {
  runApp(
    BlocProvider(
      create: (context) => AuthBloc(AuthService()),
      child: MyApp(),
    ),
  );
}

// 主应用
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: BlocBuilder<AuthBloc, AuthState>(
        builder: (context, state) {
          if (state is AuthAuthenticated) {
            return HomePage(user: state.user);
          }
          return LoginPage();
        },
      ),
    );
  }
}

// 登录页面
class LoginPage extends StatefulWidget {
  @override
  _LoginPageState createState() => _LoginPageState();
}

class _LoginPageState extends State<LoginPage> {
  final _usernameController = TextEditingController();
  final _passwordController = TextEditingController();
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('登录')),
      body: BlocConsumer<AuthBloc, AuthState>(
        listener: (context, state) {
          if (state is AuthUnauthenticated && state.message != null) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(content: Text(state.message!)),
            );
          }
        },
        builder: (context, state) {
          return Padding(
            padding: EdgeInsets.all(16.0),
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                TextField(
                  controller: _usernameController,
                  decoration: InputDecoration(labelText: '用户名'),
                ),
                TextField(
                  controller: _passwordController,
                  decoration: InputDecoration(labelText: '密码'),
                  obscureText: true,
                ),
                SizedBox(height: 20),
                if (state is AuthLoading)
                  CircularProgressIndicator()
                else
                  ElevatedButton(
                    onPressed: () {
                      context.read<AuthBloc>().add(
                        LoginEvent(
                          _usernameController.text,
                          _passwordController.text,
                        ),
                      );
                    },
                    child: Text('登录'),
                  ),
              ],
            ),
          );
        },
      ),
    );
  }
}

// 主页
class HomePage extends StatelessWidget {
  final User user;
  
  HomePage({required this.user});
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('主页'),
        actions: [
          IconButton(
            icon: Icon(Icons.logout),
            onPressed: () {
              context.read<AuthBloc>().add(LogoutEvent());
            },
          ),
        ],
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('欢迎, ${user.name}!', style: TextStyle(fontSize: 24)),
            Text('ID: ${user.id}'),
          ],
        ),
      ),
    );
  }
}

6. 结论

Flutter中的状态管理没有一种通用的最佳解决方案，选择取决于多种因素：

• 项目规模和复杂度
• 团队经验和熟悉度
• 性能需求
• 开发速度需求
• 代码可维护性需求