Flutter业务逻辑管理插件codenic_bloc_use_case的使用

Flutter业务逻辑管理插件codenic_bloc_use_case的使用

Code analysis Code coverage License Pub version Workflow status

codenic_bloc_use_case 提供了一套抽象的用例模板（由 BloC cubits 驱动），你可以扩展这些模板来定义和创建应用程序的用例，作为你清洁架构的一部分。

该包受到 Reso Coder 的 TDD 清洁架构 的启发。

了解更多，请访问 Codenic Bloc Use Case 文档

Codenic

示例代码

main.dart

// ignore_for_file: avoid_print

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:codenic_bloc_use_case/codenic_bloc_use_case.dart';

import 'src/simple_bloc_observer.dart';

part 'runner_sample.dart';
part 'watcher_sample.dart';

/// 运行方法：
/// ```bash
/// dart run example/main.dart
/// ```
///
/// 查看完整示例代码，请访问
/// https://github.com/CodenicCoders/codenic_bloc_use_case/tree/master/example

Future<void> main() async {
  Bloc.observer = SimpleBlocObserver();

  print(
    'Enter [0] for Runner, [1] for Watcher: ',
  );

  final input = stdin.readLineSync(encoding: utf8);

  switch (input) {
    case '0':
      await runner();
    case '1':
      await watcher();
  }
}

runner_sample.dart

part of 'main.dart';

Future<void> runner() async {
  print('Runner Sample');

  // 创建一个简单的 UseCase
  final simpleUseCase = SimpleUseCase();

  // 执行 UseCase
  final result = await simpleUseCase.execute();

  print('Result: $result');
}

class SimpleUseCase extends UseCase<String, NoParams> {
  @override
  FutureOr<String> call(NoParams params) {
    return 'Hello, World!';
  }
}

watcher_sample.dart

part of 'main.dart';

Future<void> watcher() async {
  print('Watcher Sample');

  // 创建一个简单的 Stream UseCase
  final streamUseCase = StreamUseCase();

  // 监听 UseCase
  streamUseCase.stream.listen((event) {
    print('Event: $event');
  });

  // 触发事件
  streamUseCase.addEvent('Hello, World!');
}

class StreamUseCase extends StreamUseCase<String, String> {
  final StreamController<String> _controller = StreamController<String>();

  @override
  Stream<String> call(String params) {
    return _controller.stream;
  }

  void addEvent(String event) {
    _controller.add(event);
  }

  @override
  Future<void> close() {
    return _controller.close();
  }
}

simple_bloc_observer.dart

import 'package:flutter_bloc/flutter_bloc.dart';

class SimpleBlocObserver extends BlocObserver {
  @override
  void onEvent(Bloc bloc, Object event) {
    super.onEvent(bloc, event);
    print('onEvent $event');
  }

  @override
  void onChange(BlocBase bloc, Change change) {
    super.onChange(bloc, change);
    print('onChange $change');
  }

  @override
  void onTransition(Bloc bloc, Transition transition) {
    super.onTransition(bloc, transition);
    print('onTransition $transition');
  }

  @override
  void onError(BlocBase bloc, Object error, StackTrace stackTrace) {
    print('onError $error');
    super.onError(bloc, error, stackTrace);
  }
}

总结

通过 codenic_bloc_use_case，你可以轻松地将业务逻辑与 UI 分离，实现更清晰、更可维护的代码结构。希望以上示例能帮助你更好地理解和使用这个插件。如果你有任何问题或建议，欢迎访问 Codenic Bloc Use Case 文档 或在 GitHub 上提交 issue。


更多关于Flutter业务逻辑管理插件codenic_bloc_use_case的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter业务逻辑管理插件codenic_bloc_use_case的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


当然，以下是一个关于如何在Flutter项目中使用codenic_bloc_use_case插件来管理业务逻辑的示例。这个插件通常与Bloc架构模式一起使用，可以帮助你更好地组织和管理应用程序的状态和逻辑。

首先，你需要确保在pubspec.yaml文件中添加了codenic_bloc_use_case及其依赖项：

dependencies:
  flutter:
    sdk: flutter
  bloc: ^8.0.0  # 确保版本与codenic_bloc_use_case兼容
  flutter_bloc: ^8.0.0
  codenic_bloc_use_case: ^最新版本号  # 替换为实际最新版本号

然后，运行flutter pub get来安装这些依赖项。

接下来，我们将创建一个简单的用例来演示如何使用codenic_bloc_use_case。

1. 定义Use Case

首先，我们定义一个简单的Use Case，比如一个用于获取用户数据的Use Case。

// user_use_case.dart
import 'package:bloc/bloc.dart';
import 'package:codenic_bloc_use_case/codenic_bloc_use_case.dart';
import 'package:flutter/material.dart';

class UserUseCase extends UseCase<UserEvent, UserState> {
  UserUseCase() : super(
    initialState: UserState.initial(),
    on: {
      UserEvent.fetchRequested: _mapFetchRequestedToState,
    },
  ) {}

  UserState _mapFetchRequestedToState(UserEvent event, UserState state) async {
    // 模拟一个异步的API调用
    await Future.delayed(Duration(seconds: 2));
    return state.copyWith(user: User(name: 'John Doe', email: 'john.doe@example.com'));
  }
}

class UserEvent extends Equatable {
  static const fetchRequested = UserEvent._('fetchRequested');

  const UserEvent._(String type) : super([type]);
}

@immutable
class UserState {
  final User? user;
  final bool isLoading;

  const UserState({this.user, this.isLoading = false}) : assert(isLoading != null);

  UserState copyWith({User? user, bool? isLoading}) {
    return UserState(
      user: user ?? this.user,
      isLoading: isLoading ?? this.isLoading,
    );
  }

  factory UserState.initial() {
    return UserState(user: null, isLoading: false);
  }

  @override
  List<Object?> get props => [user, isLoading];
}

class User {
  final String name;
  final String email;

  const User({required this.name, required this.email});
}

2. 创建Bloc和Repository（如果需要）

虽然在这个简单的例子中我们直接在Use Case中模拟了API调用，但在真实场景中，你可能会有一个Repository来处理数据获取，并通过Bloc来管理状态。

3. 使用BlocProvider和BlocBuilder

在你的Flutter组件中，使用BlocProvider来提供Bloc实例，并使用BlocBuilder来监听状态变化。

// main.dart
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'user_use_case.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('User Info')),
        body: BlocProvider<UserUseCase>(
          create: (context) => UserUseCase(),
          child: UserScreen(),
        ),
      ),
    );
  }
}

class UserScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocBuilder<UserUseCase, UserState>(
      builder: (context, state) {
        if (state.isLoading) {
          return Center(child: CircularProgressIndicator());
        }
        return Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Text('Name: ${state.user?.name ?? 'Loading...'}'),
              Text('Email: ${state.user?.email ?? 'Loading...'}'),
              ElevatedButton(
                onPressed: () => context.read<UserUseCase>().add(UserEvent.fetchRequested),
                child: Text('Fetch User'),
              ),
            ],
          ),
        );
      },
    );
  }
}

在这个示例中，我们创建了一个简单的Use Case来处理用户数据的获取，并在UI中通过BlocProvider和BlocBuilder来监听状态变化。当你点击按钮时，会触发一个事件来请求数据，并在数据加载完成后更新UI。

这个示例应该能够帮助你理解如何在Flutter项目中使用codenic_bloc_use_case插件来管理业务逻辑。如果你有更复杂的需求，可以根据实际情况扩展这个示例。

回到顶部