如何为Vert.x编写基于jCasbin的自定义授权实现？

当然可以单独实现授权功能！Vert.x的认证与授权模块是完全解耦的，官方提供的那些同时包含认证+授权的实现只是整合方案，你完全可以只专注于授权逻辑的开发，不用绑定任何认证组件。下面是一步步的实现思路和代码示例：

1. 先搞懂Vert.x的授权核心接口 #

Vert.x中负责授权的核心是Authorization接口，它只关注“已认证的用户是否有权限访问某个资源/执行某个动作”，完全不需要处理用户登录、身份验证的逻辑。你只需要实现这个接口的核心方法，就能自定义授权逻辑。

如果需要更灵活的实例管理，可以配合AuthorizationProvider接口来创建Authorization实例，但如果逻辑简单，直接实例化自定义的Authorization类也完全够用。

2. 集成jCasbin到Vert.x授权逻辑 #

核心思路是：在Authorization的authorize方法中，提取用户身份、请求的资源和动作，调用jCasbin的enforce方法做权限判断，然后返回结果。

步骤分解： #

• 初始化jCasbin Enforcer：提前加载你的权限模型（比如RBAC模型）和策略规则，这个可以在Vert.x启动时完成，做成单例避免重复初始化。
• 提取授权所需信息：从Vert.x的User对象中获取用户名（或其他身份标识），从请求上下文里提取资源（比如请求路径）和动作（比如HTTP方法）。
• 调用jCasbin判断权限：把这些参数传入enforcer.enforce()，根据返回的布尔值决定允许或拒绝请求。

3. 代码示例 #

自定义Authorization实现 #

import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.ext.auth.User;
import io.vertx.ext.auth.authorization.Authorization;
import io.vertx.ext.auth.authorization.AuthorizationContext;
import org.casbin.jcasbin.main.Enforcer;

public class JCasbinAuthorization implements Authorization {
    private final Enforcer enforcer;

    // 构造函数传入jCasbin的Enforcer实例
    public JCasbinAuthorization(Enforcer enforcer) {
        this.enforcer = enforcer;
    }

    @Override
    public void authorize(User user, AuthorizationContext context, Handler<AsyncResult<Void>> handler) {
        // 从User对象中获取用户名（假设认证后User的principal里包含username字段）
        String username = user.principal().getString("username");
        if (username == null) {
            handler.handle(Future.failedFuture("Missing user identity"));
            return;
        }

        // 从AuthorizationContext获取请求资源和动作（这里我们提前存入了路径和HTTP方法）
        String resource = context.get("path");
        String action = context.get("method");

        // 调用jCasbin执行权限判断
        boolean isAllowed = enforcer.enforce(username, resource, action);

        if (isAllowed) {
            // 权限通过，继续处理请求
            handler.handle(Future.succeededFuture());
        } else {
            // 权限拒绝，返回403
            handler.handle(Future.failedFuture(403, "Forbidden: No permission to access this resource"));
        }
    }

    @Override
    public String getId() {
        // 返回授权器的唯一标识，可自定义
        return "jcasbin-authorization";
    }
}

在Vert.x路由中使用自定义授权 #

import io.vertx.core.Vertx;
import io.vertx.ext.web.Router;
import io.vertx.ext.auth.User;
import io.vertx.ext.auth.authorization.AuthorizationContext;
import org.casbin.jcasbin.main.Enforcer;

public class MainVerticle extends io.vertx.core.AbstractVerticle {
    @Override
    public void start() {
        // 1. 初始化jCasbin Enforcer（加载模型和策略文件）
        Enforcer enforcer = Enforcer.newEnforcer("path/to/model.conf", "path/to/policy.csv");

        // 2. 创建自定义授权实例
        JCasbinAuthorization casbinAuthz = new JCasbinAuthorization(enforcer);

        // 3. 创建Vert.x路由
        Router router = Router.router(vertx);

        // 假设你已经有认证逻辑（比如JWT认证），这里先处理用户认证
        // router.route().handler(JWTAuthHandler.create(jwtAuthProvider));

        // 4. 添加授权处理逻辑
        router.route().handler(ctx -> {
            User user = ctx.user();
            if (user == null) {
                // 未认证的请求直接返回401
                ctx.response().setStatusCode(401).end("Unauthorized");
                return;
            }

            // 构建AuthorizationContext，传入请求的路径和方法
            AuthorizationContext authzContext = AuthorizationContext.create();
            authzContext.put("path", ctx.request().path());
            authzContext.put("method", ctx.request().method().name());

            // 调用自定义授权逻辑
            casbinAuthz.authorize(user, authzContext, res -> {
                if (res.succeeded()) {
                    // 授权通过，继续执行后续路由
                    ctx.next();
                } else {
                    // 授权失败，返回403
                    ctx.response().setStatusCode(403).end(res.cause().getMessage());
                }
            });
        });

        // 5. 定义需要授权的路由
        router.get("/api/admin/dashboard").handler(ctx -> {
            ctx.response().end("Welcome to admin dashboard!");
        });

        router.get("/api/user/profile").handler(ctx -> {
            ctx.response().end("Your user profile");
        });

        // 启动HTTP服务器
        vertx.createHttpServer().requestHandler(router).listen(8080, res -> {
            if (res.succeeded()) {
                System.out.println("Server started on port 8080");
            } else {
                System.err.println("Failed to start server: " + res.cause());
            }
        });
    }
}

4. 额外优化建议 #

• 动态更新策略：如果你的权限策略需要动态修改，可以利用jCasbin的Watcher机制，结合Vert.x的事件总线（EventBus）来同步策略变化，避免重启服务。
• 资源/动作的灵活提取：除了路径和HTTP方法，你还可以从请求头、查询参数、请求体中提取更多信息作为jCasbin的判断参数，比如用户角色、资源ID等。
• 单例Enforcer：把jCasbin的Enforcer做成单例，或者通过Vert.x的SharedData来共享，避免每个请求都初始化一次，提升性能。

内容的提问来源于stack exchange，提问作者hsluoyz