Flutter数据序列化与反序列化插件chopper_built_value的使用

chopper_built_value 是一个基于 built_value 的转换器，可以与 Chopper 一起使用来实现对象到 JSON 和 JSON 到对象的相互转换。本文将介绍如何在 Flutter 应用中使用这个插件，并提供一个完整的示例 demo。

环境准备

首先，确保你的 Flutter 项目已经安装了必要的依赖项：

dependencies:
  flutter:
    sdk: flutter
  chopper: ^4.0.0
  built_value: ^8.0.0
  chopper_built_value: ^0.2.0

dev_dependencies:
  build_runner: ^2.0.0
  built_value_generator: ^8.0.0

运行 flutter pub get 来安装这些依赖。

创建数据模型

使用 built_value 来定义数据模型。以下是一个简单的例子：

import 'package:built_value/built_value.dart';
import 'package:built_value/serializer.dart';

part 'user.g.dart';

abstract class User implements Built<User, UserBuilder> {
  String get id;
  String get name;
  int get age;

  User._();
  factory User([void Function(UserBuilder) updates]) = _$User;

  static Serializer<User> get serializer => _$userSerializer;
}

运行 flutter pub run build_runner build 来生成相应的代码。

配置序列化器

接下来，配置 Serializers 来支持你的数据模型：

import 'package:built_value/serializer.dart';
import 'package:built_collection/built_collection.dart';
import 'user.g.dart';

part 'serializers.g.dart';

@SerializersFor([
  User,
])
final Serializers serializers = (_$serializers.toBuilder()..addPlugin(StandardJsonPlugin())).build();

// Run `flutter pub run build_runner build` to generate this file.

同样需要运行 flutter pub run build_runner build 来生成相应的代码。

使用 Chopper 和 chopper_built_value

现在我们来设置 Chopper 并使用 chopper_built_value 插件：

import 'package:chopper/chopper.dart';
import 'package:chopper_built_value/chopper_built_value.dart';
import 'serializers.dart';
import 'user.g.dart';

part 'api_service.chopper.dart';

@ChopperApi(baseUrl: '/api')
abstract class ApiService extends ChopperService {
  static ApiService create(ChopperClient client) => _$ApiService(client);

  @Get(path: 'users/{id}')
  Future<Response<User>> getUser(@Path('id') String id);

  @Post(path: 'users')
  Future<Response<User>> createUser(@Body() User user);
}

void setupChopper() {
  final client = ChopperClient(
    baseUrl: 'https://example.com',
    services: [
      ApiService.create(),
    ],
    converter: BuiltValueConverter(serializers),
  );

  final apiService = ApiService.create(client);

  // 示例调用
  apiService.getUser('1').then((response) {
    print(response.body);
  });
}

完整示例 Demo

以下是完整的一个示例应用，展示了如何使用上述配置进行网络请求和数据序列化：

import 'package:flutter/material.dart';
import 'package:chopper/chopper.dart';
import 'api_service.chopper.dart';
import 'setup_chopper.dart';

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

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Chopper with built_value Example'),
        ),
        body: Center(
          child: FutureBuilder<Response<User>>(
            future: setupChopper().getUser('1'),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.done) {
                if (snapshot.hasError) {
                  return Text('Error: ${snapshot.error}');
                }

                final user = snapshot.data?.body;
                return Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: <Widget>[
                    Text('ID: ${user?.id}'),
                    Text('Name: ${user?.name}'),
                    Text('Age: ${user?.age}'),
                  ],
                );
              } else {
                return CircularProgressIndicator();
              }
            },
          ),
        ),
      ),
    );
  }
}

Future<Response<User>> setupChopper() async {
  final client = ChopperClient(
    baseUrl: 'https://example.com',
    services: [
      ApiService.create(),
    ],
    converter: BuiltValueConverter(serializers),
  );

  final apiService = ApiService.create(client);

  return await apiService.getUser('1');
}