Flutter路由注解插件revali_router_annotations的使用

Flutter路由注解插件revali_router_annotations的使用

介绍

revali_router_annotations 是 revali_router 包的基础注解包。它提供了用于在 Revali 中定义控制器和端点的核心注解。

使用文档

要了解更多关于如何使用 Revali 的信息，请查看其官方文档。

示例代码

// ignore_for_file: avoid_print

import 'dart:io';

import 'package:revali_router/revali_router.dart';

void main() async {
  // 绑定服务器到 localhost:8080
  final server = await HttpServer.bind(
    'localhost',
    8080,
  );

  // 处理请求
  handleRequests(server, (context) async {
    // 初始化路由器
    final router = Router(
      routes: routes,
      reflects: {
        Reflect(
          User,
          metas: (m) {
            m['user'].add(const Role('admin'));
          },
        ),
      },
    );

    // 处理路由请求并返回响应
    final response = await router.handle(context);

    return response;
  }).ignore();

  // 打印服务地址
  print('Serving at http://${server.address.host}:${server.port}');
}

// 定义路由
final routes = [
  Route(
    '', // 路由路径
    method: 'GET', // HTTP 方法
    handler: (context) async {}, // 请求处理器
  ),
  Route(
    'user', // 路由路径
    catchers: [AuthExceptionCatcher()], // 异常捕获器
    routes: [
      Route(
        ':id', // 路由路径
        catchers: const [], // 异常捕获器
        guards: const [AuthGuard()], // 守卫
        handler: (context) async {
          // 设置响应状态码和响应体
          context.response.statusCode = 200;
          context.response.body = {'id': 'hi'};
        },
        interceptors: const [BodyInterceptor()], // 拦截器
        meta: (m) {}, // 元数据
        method: 'GET', // HTTP 方法
        middlewares: [AddAuth()], // 中间件
        routes: const [], // 子路由
      ),
      Route(
        '', // 路由路径
        method: 'POST', // HTTP 方法
        handler: (context) async {
          // 获取请求体
          final body = context.request.body;
          print(body);

          // 设置响应状态码和响应体
          context.response.statusCode = 200;
          context.response.body = {'id': 'hi'};
        },
      ),
    ],
  ),
];

// 定义守卫
class AuthGuard implements Guard {
  const AuthGuard();

  [@override](/user/override)
  Future<GuardResult> canActivate(
    GuardContext context,
    GuardAction canActivate,
  ) async {
    // 获取上下文数据中的认证信息
    final hasAuth = context.data.get<HasAuth>();

    // 如果认证信息不存在，则抛出异常
    if (hasAuth case null) {
      throw AuthException();
    }

    // 如果认证失败，则返回拒绝
    if (!hasAuth.hasAuth) {
      return canActivate.no();
    }

    // 如果认证成功，则返回允许
    return canActivate.yes();
  }
}

// 定义中间件
class AddAuth implements Middleware {
  [@override](/user/override)
  Future<MiddlewareResult> use(
    MiddlewareContext context,
    MiddlewareAction action,
  ) async {
    // 添加认证信息
    context.data.add(HasAuth(hasAuth: true));

    // 继续执行下一个中间件
    return action.next();
  }
}

// 定义认证信息类
class HasAuth {
  HasAuth({required this.hasAuth});
  final bool hasAuth;
}

// 定义认证异常类
class AuthException implements Exception {}

// 定义异常捕获器
class AuthExceptionCatcher extends ExceptionCatcher<AuthException> {
  [@override](/user/override)
  ExceptionCatcherResult catchException(
    AuthException e,
    ExceptionCatcherContext context,
    ExceptionCatcherAction action,
  ) {
    // 处理异常，设置响应状态码和响应体
    return action.handled(
      statusCode: 401,
      body: 'Unauthorized',
    );
  }
}

// 定义用户类
class User {
  const User(this.name);

  final String name;
}

// 定义角色类
class Role {
  const Role(this.name);

  final String name;
}

// 定义拦截器
class BodyInterceptor implements Interceptor {
  const BodyInterceptor();

  [@override](/user/override)
  Future<void> post(InterceptorContext context) async {
    // 在请求后处理操作
    final reflect = context.reflect.get<User>();

    reflect?.meta.entries;

    reflect?.meta['user']?.has<Role>();
  }

  [@override](/user/override)
  Future<void> pre(InterceptorContext context) async {
    // 在请求前处理操作
  }
}