Dart基础4-反射

mirror

mirror.png

1. 反射类

ClassMirror

1.1 获取反射类对象

external ClassMirror reflectClass(Type key);

Type 类型， 即 class类的类名（var、dynamic这些关键字不记入）

使用

abstract class Test{}
ClassMirror classMirror = reflectClass(Test); //类名即是Type

1.2 反射类分析

abstract class ClassMirror implements TypeMirror, ObjectMirror {

  ClassMirror get superclass;  //父类 ， Object的父类为null

  List<ClassMirror> get superinterfaces; //接口列表

  bool get isAbstract; //是否抽象类

  bool get isEnum;     //是否枚举类

  //只包含自己原本的方法（构造方法、setter/getter、普通方法、静态方法）、成员（普通成员、静态成员），不包含继承来的
  //注意: 属性是VariableMirror，实现了setter/getter的属性为MethodMirror
  Map<Symbol, DeclarationMirror> get declarations;

  //包含构造方法、setter/getter、普通方法，包含继承来的
  Map<Symbol, MethodMirror> get instanceMembers;

  //静态方法及静态属性的setter/getter方法，包含继承来的
  //与instanceMembers合在一起就是类中全部的方法
  Map<Symbol, MethodMirror> get staticMembers;

  //如果S = A with B ,那么ClassMirror（S）.mixin 为 ClassMirror（B），否则返回本身
  ClassMirror get mixin;

  /**
   * 调用构造方法
   * constructorName 构造方法名称（默认构造方法为空字符串，命名构造方法为其命名）
   * positionalArguments 参数列表
   */
  InstanceMirror newInstance(Symbol constructorName, List positionalArguments,
      [Map<Symbol, dynamic> namedArguments]);

  bool operator ==(other); //判断是否相等

  bool isSubclassOf(ClassMirror other); //判断是不是other的子类
}

Symbol

abstract class Symbol {
  
  static const Symbol unaryMinus = const Symbol("unary-");

  static const Symbol empty = const Symbol("");

  //构造方法,也可使用#来创建
  //Symbol("A") == #A
  const factory Symbol(String name) = internal.Symbol;

  int get hashCode;

  bool operator ==(other);
}

Symbol创建

class A { var a = 1;}
Symbol("A") == #A                //方法、类、参数直接用名字
Symbol("A.t") == #A.t            //命名构造方法也是直接用名字
Symbol("a=") == #a=              //属性set方法(私有属性即为#_a=)
Symbol("a") == #a                //属性get方法
Symbol("==") == #==              //操作符直接使用符号 
Symbol("") == Symbol.empty 

1.3 示例：使用构造方法

import 'dart:mirrors';
class A{
  int a;
  A(this.a){
    print(a);
  }
}
main(){
  ClassMirror classMirror = reflectClass(A);   
  classMirror.newInstance(Symbol.empty ,[1]); //调用构造方法，打印1
}

2. 方法反射

abstract class MethodMirror implements DeclarationMirror {

  TypeMirror get returnType; //反射类型

  String get source; //source code ， 不可用返回null

  List<ParameterMirror> get parameters; //参数列表

  bool get isStatic; //是否静态方法

  bool get isAbstract;//是否抽象方法

  bool get isSynthetic;//Synthetic方法（即隐式的setter/getter或构造方法[只定义属性或无构造函数]）

  bool get isRegularMethod; //常规方法（即非setter/getter、构造方法）

  bool get isOperator; //操作符方法

  bool get isGetter; //get方法

  bool get isSetter; //set方法

  bool get isConstructor;      //判断是否构造方法

  Symbol get constructorName;   //获得构造方法的名字，默认构造方法为空字符串

  bool get isConstConstructor;   //常量构造方法

  bool get isGenerativeConstructor;

  bool get isRedirectingConstructor;//重定向构造方法

  bool get isFactoryConstructor;  //工厂构造方法

  bool operator ==(other);
}

abstract class DeclarationMirror implements Mirror {

  Symbol get simpleName; //简称

  Symbol get qualifiedName; //全称，包含路径

  //库 -> null
  //类、顶级函数或变量、typedef -> 库
  //S with M -> M
  //类中的方法、变量 -> 类
  //函数中的局部变量、函数 -> 函数
  DeclarationMirror get owner;  //所有者

  bool get isPrivate;  //私有

  bool get isTopLevel;  //顶级

  //格式：dart:core/runtime/libobject_patch.dart:53
  SourceLocation get location; //来源，标明方法、类、属性所在文件的位置

  List<InstanceMirror> get metadata; //元数据列表
}

2.1 示例：元数据对象获取

import 'dart:mirrors';
@Todo('todo', 'work')
class A{
  int a;
  A(this.a){
    print(a);
  }
}

class Todo {
  final String who;
  final String what;
  const Todo(this.who, this.what);
}

main(){
  ClassMirror classMirror = reflectClass(A);
  // 获取 class 上的元数据
  classMirror.metadata.forEach((metadata) {
    print(metadata.reflectee.who + ' ==> ' + metadata.reflectee.what);
  });
}

3. 对象反射

abstract class InstanceMirror implements ObjectMirror {
 
  ClassMirror get type;  //类型

  bool get hasReflectee;

  get reflectee;//反射一个实体对象（hasReflectee==false，抛异常）

  bool operator ==(other);
}

在得到一个InstanceMirror对象后，即可调用InstanceMirror.reflectee获得想要反射的对象

3.1 示例：反射对象

import 'dart:mirrors';
class A{
  int a;
  A(this.a){
    print(a);
  }
}

main(){
  ClassMirror classMirror = reflectClass(A);
  var instance = classMirror.newInstance(Symbol.empty ,[1]); //调用构造方法，打印1
  print(instance.reflectee.a);//instance.reflectee： A对象， 打印1
}

4. 属性反射

variableMirror 类属性或顶级属性

• isStatic 静态
• isFinal
• isConst
• type 返回类型反射TypeMirror

ParameterMirror 函数的参数

• isOptional 可选位置参数（[]）
• isNamed 可选命名参数（{}）
• hasDefaultValue 是否有默认值
• defaultValue 获取默认值对象反射

5. 类型反射

TypeMirror 比如：List<int>

• reflectedType 类型 List<int>
• typeVariables 类型变量集合 ， E( List中类型变量是E )
• typeArguments 类型集合 , int

TypedefMirror

TypeVariableMirror 代指泛型的类型变量（如: T）

• upperBound 上界 ， T extends M ,返回 M
• isStatic

TypedefMirror 类型别名

• referent 返回函数类型反射FunctionTypeMirror

FunctionTypeMirror 函数类型反射

//typedef A<T> = int Function(T a, T b);
abstract class FunctionTypeMirror implements ClassMirror {
  
  TypeMirror get returnType;  //返回类型反射 int

  List<ParameterMirror> get parameters; // 参数反射集合

  MethodMirror get callMethod;
}

示例

import 'dart:mirrors';
typedef F<T> = int Function(T a);

class A<T>{
 List<int> a;
 F<int> a2;
}

main(List<String> args) {
  getAnnotation();
}

void getAnnotation() {

  ClassMirror classMirror = reflectClass(A);
  classMirror.declarations.forEach((Symbol key, DeclarationMirror value) {
    //获取属性a和a2的反射
    if(value is VariableMirror){
      //获取属性的类型
      var type = value.type;
      print(type.reflectedType);
      //函数类型反射
      if(type is FunctionTypeMirror){
        print(type.returnType);
        type.parameters.forEach((value)=>print(value));
        return;
      }
      type.typeVariables.forEach((value)=>print(value));
      type.typeArguments.forEach((value)=>print(value));
    }
  });
}
}

6. 示例

import 'dart:mirrors';

@Todo('todo1', 'A')
class A{
  @Todo('todo2', 'a')
  int a;
  A(this.a){
    print(a);
  }
  @Todo('todo3', 'doA')
  doA(@Todo('todo4', 'x')int x){}
}

class Todo {
  final String who;
  final String what;
  const Todo(this.who, this.what);
}

main(List<String> args) {
  getAnnotation();
}

void getAnnotation() {
  ClassMirror classMirror = reflectClass(A);

  // 1.获取 class 上的元数据
  classMirror.metadata.forEach((metadata) {
    //因为示例就一个元数据，后续就省略判断了
    if (metadata.reflectee is Todo) {
      print(metadata.reflectee.who + ' ==> ' + metadata.reflectee.what);
    }
  });

  //declarations,获取A类所有的方法和属性（没有继承）
  classMirror.declarations.forEach((Symbol key, DeclarationMirror value) {
    //属性是VariableMirror
    if(value is VariableMirror){
      // 2.属性上的元数据
      value.metadata.forEach((metadata) {
        print(metadata.reflectee.who + ' ==> ' + metadata.reflectee.what);
      });
    }

    if (value is MethodMirror) {
      // 3.方法上的元数据
      value.metadata.forEach((metadata) {
        print(metadata.reflectee.who + ' ==> ' + metadata.reflectee.what);
      });
      // 方法里的参数列表
      value.parameters.forEach((param) {
        //4.方法里参数的元数据
        param.metadata.forEach((metadata) {
          print(metadata.reflectee.who + ' ==> ' + metadata.reflectee.what);
        });
      });
    }
  });
}

---

ps: flutter中禁止开发者使用mirrors，无法进行反射