Flutter反射机制插件built_mirrors的使用

Flutter反射机制插件built_mirrors的使用

built_mirrors 是一个用于生成 ClassMirror 的库，它可以从带有 @reflectable 或 @Reflectable() 注解的类中生成反射信息。通过这个库，你可以在运行时动态地获取类的结构、构造函数、方法和字段等信息。

1. 创建一个新的Dart项目

首先，创建一个新的Dart项目（可以是Flutter项目）。你可以使用以下命令来创建一个新项目：

flutter create my_project

2. 添加依赖

在 pubspec.yaml 文件中添加 built_mirrors 和 built_runner 依赖。确保使用最新的版本号。

dependencies:
  built_mirrors: any

dev_dependencies:
  built_runner: any

3. 创建模型文件

在 lib 文件夹中创建一个名为 models.dart 的文件，并将以下代码粘贴到该文件中。这个文件定义了一些带有注解的类，这些类将被 built_mirrors 生成反射信息。

library built_mirrors.example.models;

import 'package:built_mirrors/built_mirrors.dart';

part 'models.g.dart';

class MyAnnotation extends Annotation {
  final String val1;
  final val2;
  const MyAnnotation(this.val1, {this.val2});
}

const myOtherAnnotation = _MyOtherAnnotation();
class _MyOtherAnnotation extends Annotation {
  const _MyOtherAnnotation();
}

@reflectable
class Person {
  Person({this.id, this.name, this.myDynamic, this.cars});
  int? id;
  @MyAnnotation('hello\uabcd', val2: null)
  String? name;
  var myDynamic;
  List<Car>? cars;

  String get myGetter => 'myGetter result';
  set mySetter(String val) => 'setting $val';
}

@reflectable
@myOtherAnnotation
class Car {
  int? id;
  @MyAnnotation(r'\uabcd', val2: null)
  String? engine;
  Car([this.id, this.engine]);
}

@reflectable
class EmptyClass {}

@reflectable
class ExtendedPerson extends Person {
  var extendedName;
  var otherExtended;
}

@reflectable
class ClassWithMethod {
  @myOtherAnnotation
  someMethod(@myOtherAnnotation String someParameter) {
    return 'someMethod';
  }

  @myOtherAnnotation
  someMethodWithNamedParams({@myOtherAnnotation String? someParameter}) {
    return 'someMethod';
  }
}

4. 编辑主文件

在 lib 文件夹中创建或编辑 main.dart 文件，并将以下代码粘贴到该文件中。这个文件展示了如何使用 built_mirrors 来反射类和方法。

library built_mirrors.example.main;

import 'models.dart';
import 'package:built_mirrors/built_mirrors.dart';

part 'main.g.dart';

@reflectable
@AnnotationWithFunction(otherFunction)
String someFunction(@myOtherAnnotation int p1, int p0, int p2) {
  return '';
}

void otherFunction() {}

class AnnotationWithFunction extends Annotation {
  const AnnotationWithFunction(this.function);

  final Function function;
}

void main() {
  // 初始化反射映射
  _initMirrors();

  // 获取 Person 类的 ClassMirror
  var personClassMirror = reflectType(Person);
  
  // 使用构造函数参数创建一个新的 Person 实例
  var p1 = personClassMirror?.constructors?['']?.call([], {'id': 1, 'name': 'person 1'});
  
  // 获取 Person 类的所有字段
  var p1Fields = personClassMirror?.fields;

  // 打印字段类型
  print("p1Fields['myDynamic'].type: ${p1Fields?['myDynamic']?.type}\n");
  print("p1Fields['cars'].type: ${p1Fields?['cars']?.type}\n");

  // 获取 Car 类的 ClassMirror 并创建一个新的 Car 实例
  Car car1 = reflectType(Car)?.constructors?['']?.call([1, 'v8']);
  print('car1:\n\tid: ${car1.id}\n\tengine: ${car1.engine}\n');

  // 将 car1 添加到 p1.cars
  p1.cars = [car1];

  print('\n--------------------------');
  print('reflecting "ClassWithMethod"');
  print('--------------------------');
  var methods = reflectType(ClassWithMethod)?.methods;
  print(methods?.keys); // 打印方法名
  print(methods?['someMethod']?.returnType); // 打印返回类型
  print(methods?['someMethod']?.annotations); // 打印注解
  print(methods?['someMethod']?.positionalParameters); // 打印位置参数
  print(methods?['someMethod']?.positionalParameters?[0].annotations); // 打印第一个位置参数的注解
  print(methods?['someMethod']?.positionalParameters?[0].type); // 打印第一个位置参数的类型

  print('\n--------------------------');
  print('reflecting "someFunction"');
  print('--------------------------');
  var sfMirror = reflectFunction(someFunction);
  print(sfMirror?.name); // 打印函数名
  print(sfMirror?.returnType); // 打印返回类型
  print(sfMirror?.annotations); // 打印注解
  print(sfMirror?.positionalParameters); // 打印位置参数
  print(sfMirror?.positionalParameters?[0].annotations); // 打印第一个位置参数的注解
  print(sfMirror?.positionalParameters?[0].type); // 打印第一个位置参数的类型
  print(sfMirror?.positionalParameters?[0].name); // 打印第一个位置参数的名称
  print(sfMirror?.positionalParameters?[1].name); // 打印第二个位置参数的名称
  print(sfMirror?.positionalParameters?[2].name); // 打印第三个位置参数的名称
}

5. 生成反射代码

在项目根目录下运行以下命令，生成反射代码。这将会生成 lib/models.g.dart 和 lib/main.g.dart 文件，包含自动生成的反射信息。

dart run build_runner build

6. 运行项目

最后，运行 main.dart 文件，如果一切正常，你将在控制台看到以下输出：

p1Fields['myDynamic'].type: dynamic
p1Fields['cars'].type: [List, Car]

car1:
        id: 1
        engine: v8

--------------------------
reflecting "ClassWithMethod"
--------------------------
(someMethod, someMethodWithNamedParams)
dynamic
[Instance of '_MyOtherAnnotation']
[DeclarationMirror on someParameter]
[Instance of '_MyOtherAnnotation']
String

--------------------------
reflecting "someFunction"
--------------------------
someFunction
String
[Instance of 'AnnotationWithFunction']
[DeclarationMirror on p1, DeclarationMirror on p0, DeclarationMirror on p2]
[Instance of '_MyOtherAnnotation']
int
p1
p0
p2