基于Vert.x框架的多层级账户REST API URL定义问询

Great question! Dealing with unknown-depth subaccount hierarchies in Vert.x doesn't have to be tricky—you can use flexible route patterns and recursive logic to handle any level of nesting. Here's a practical approach:

1. Define Wildcard Route Patterns #

Vert.x Web supports wildcard path parameters that can match multiple levels of nested paths. Instead of defining separate routes for each subaccount level, create a single route pattern that captures the entire subaccount hierarchy.

For example, replace fixed-level subaccount routes with a wildcard pattern like:

• POST /accounts/:accName/subaccount/*
• PUT /accounts/:accName/subaccount/*
• GET /accounts/:accName/subaccount/*
• DELETE /accounts/:accName/subaccount/*

Keep your existing first-level list route (GET /accounts/:accName/subaccount) intact for fetching only direct subaccounts of the main account.

2. Parse the Hierarchical Path #

In your route handlers, extract the wildcard portion of the path and split it into individual subaccount names. This gives you a list representing the full hierarchy from the main account down to the target subaccount.

Example Path Parsing #

If a request comes in for GET /accounts/myMainAcc/subaccount/sub1/sub2/sub3, the wildcard segment will be sub1/sub2/sub3. Split this string by / to get a list: ["sub1", "sub2", "sub3"].

3. Implement CRUD with Recursive Logic #

Use the parsed hierarchy list to traverse your account/subaccount structure recursively. This lets you handle any depth without hardcoding levels.

Full Example Code #

Here's how to wire this up in Vert.x:

import io.vertx.core.Vertx;
import io.vertx.core.json.Json;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class AccountApi {
    private final AccountRepository accountRepository = new AccountRepository(); // Your repo implementation

    public static void main(String[] args) {
        Vertx vertx = Vertx.vertx();
        AccountApi api = new AccountApi();
        Router router = api.setupRoutes(vertx);
        vertx.createHttpServer().requestHandler(router).listen(8080);
    }

    private Router setupRoutes(Vertx vertx) {
        Router router = Router.router(vertx);

        // Core Account Routes (as defined in your requirements)
        router.post("/accounts").handler(this::createAccount);
        router.put("/accounts").handler(this::updateAccount);
        router.get("/accounts/:accName").handler(this::getAccount);
        router.delete("/accounts/:accName").handler(this::deleteAccount);
        router.get("/accounts").handler(this::listAccounts);

        // First-level Subaccount List
        router.get("/accounts/:accName/subaccount").handler(this::listFirstLevelSubaccounts);

        // Dynamic Subaccount Routes for Any Hierarchy Depth
        router.post("/accounts/:accName/subaccount/*").handler(this::createSubaccountAtAnyLevel);
        router.put("/accounts/:accName/subaccount/*").handler(this::updateSubaccountAtAnyLevel);
        router.get("/accounts/:accName/subaccount/*").handler(this::getSubaccountAtAnyLevel);
        router.delete("/accounts/:accName/subaccount/*").handler(this::deleteSubaccountAtAnyLevel);

        return router;
    }

    // Example handler for fetching a deep subaccount
    private void getSubaccountAtAnyLevel(RoutingContext ctx) {
        String mainAccountName = ctx.pathParam("accName");
        String subHierarchy = ctx.pathParam("*");
        
        // Split and clean up the hierarchy (filter out empty strings from trailing slashes)
        List<String> subAccountNames = Arrays.stream(subHierarchy.split("/"))
                .filter(name -> !name.isBlank())
                .toList();

        // Recursively find the target subaccount
        Optional<Subaccount> targetSubaccount = findSubaccountRecursively(mainAccountName, subAccountNames);

        if (targetSubaccount.isPresent()) {
            ctx.response()
                    .putHeader("Content-Type", "application/json")
                    .end(Json.encodePrettily(targetSubaccount.get()));
        } else {
            ctx.response()
                    .setStatusCode(404)
                    .end("Subaccount hierarchy not found");
        }
    }

    // Recursive helper to traverse the hierarchy
    private Optional<Subaccount> findSubaccountRecursively(String mainAccName, List<String> subAccountNames) {
        // Fetch the main account first
        Account mainAccount = accountRepository.getByName(mainAccName);
        if (mainAccount == null) {
            return Optional.empty();
        }

        Subaccount currentSubaccount = mainAccount.getDirectSubaccounts().get(0); // Adjust to your root subaccount logic
        for (String subName : subAccountNames) {
            currentSubaccount = currentSubaccount.getSubaccountByName(subName);
            if (currentSubaccount == null) {
                return Optional.empty();
            }
        }
        return Optional.of(currentSubaccount);
    }

    // Implement other handlers (createAccount, updateSubaccountAtAnyLevel, etc.) similarly
    private void createAccount(RoutingContext ctx) { /* ... */ }
    private void updateAccount(RoutingContext ctx) { /* ... */ }
    private void getAccount(RoutingContext ctx) { /* ... */ }
    private void deleteAccount(RoutingContext ctx) { /* ... */ }
    private void listAccounts(RoutingContext ctx) { /* ... */ }
    private void listFirstLevelSubaccounts(RoutingContext ctx) { /* ... */ }
    private void createSubaccountAtAnyLevel(RoutingContext ctx) { /* ... */ }
    private void updateSubaccountAtAnyLevel(RoutingContext ctx) { /* ... */ }
    private void deleteSubaccountAtAnyLevel(RoutingContext ctx) { /* ... */ }
}

// Dummy classes for illustration
class Account {
    private String name;
    private List<Subaccount> directSubaccounts;
    // Getters/setters
    public List<Subaccount> getDirectSubaccounts() { return directSubaccounts; }
    public String getName() { return name; }
}

class Subaccount {
    private String name;
    private List<Subaccount> subaccounts;
    // Getters/setters
    public Subaccount getSubaccountByName(String name) {
        return subaccounts.stream().filter(s -> s.name.equals(name)).findFirst().orElse(null);
    }
}

class AccountRepository {
    public Account getByName(String name) { /* ... */ return null; }
}

Key Considerations #

• Path Validation: Always filter out empty strings when splitting the hierarchy path (to handle cases where the URL ends with a trailing slash).
• POST Semantics: For creating a new subaccount, the wildcard path should represent the parent hierarchy. The new subaccount's name and details can be sent in the request body.
• Error Handling: Add checks for invalid paths, non-existent accounts/subaccounts, and return appropriate HTTP status codes (404, 400, etc.).
• Performance: If your hierarchy is very deep, consider caching frequent lookups to avoid excessive recursive database calls.

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