Ich habe die aktuellen Routen implementiert (zum Beispiel):

GET     /api/:version/:entity               my.controllers.~~~~~
GET     /api/:version/:entity/:id           my.controllers.~~~~~
POST    /api/:version/:entity               my.controllers.~~~~~
POST    /api/:version/:entity/:id           my.controllers.~~~~~
DELETE  /api/:version/:entity               my.controllers.~~~~~

POST    /api/:version/search/:entity        my.controllers.~~~~~

Und sie arbeiten wunderschön. Angenommen, ich möchte einen "Batch-Endpunkt" für dieselbe API implementieren. Es sollte ungefähr so aussehen:

POST    /api/:version/batch                 my.controllers.~~~~~

und der Körper sollte so aussehen:

[
    {
        "method": "POST",
        "call": "/api/1/customer",
        "body": {
            "name": "antonio",
            "email": "[email protected]"
        }
    },
    {
        "method": "POST",
        "call": "/api/1/customer/2",
        "body": {
            "name": "mario"
        }
    },
    {
        "method": "GET",
        "call": "/api/1/company"
    },
    {
        "method": "DELETE",
        "call": "/api/1/company/22"
    }
]

Dazu möchte ich wissen, wie ich den Play Framework Router anrufen kann, um diese Anfragen weiterzuleiten? Ich hatte vor, etwas Ähnliches zu verwenden, wie es für Unit-Tests empfohlen wird:

@Test
public void badRoute() {
  Result result = play.test.Helpers.routeAndCall(fakeRequest(GET, "/xx/Kiki"));
  assertThat(result).isNull();
} 

indem Sie in den Quellcode vonrouteAndCall()Sie finden so etwas:

 /**
 * Use the Router to determine the Action to call for this request and executes it.
 * @deprecated
 * @see #route instead
 */
@SuppressWarnings(value = "unchecked")
public static Result routeAndCall(FakeRequest fakeRequest) {
    try {
        return routeAndCall((Class<? extends play.core.Router.Routes>)FakeRequest.class.getClassLoader().loadClass("Routes"), fakeRequest);
    } catch(RuntimeException e) {
        throw e;
    } catch(Throwable t) {
        throw new RuntimeException(t);
    }
}

/**
 * Use the Router to determine the Action to call for this request and executes it.
 * @deprecated
 * @see #route instead
 */
public static Result routeAndCall(Class<? extends play.core.Router.Routes> router, FakeRequest fakeRequest) {
    try {
        play.core.Router.Routes routes = (play.core.Router.Routes)router.getClassLoader().loadClass(router.getName() + "$").getDeclaredField("MODULE$").get(null);
        if(routes.routes().isDefinedAt(fakeRequest.getWrappedRequest())) {
            return invokeHandler(routes.routes().apply(fakeRequest.getWrappedRequest()), fakeRequest);
        } else {
            return null;
        }
    } catch(RuntimeException e) {
        throw e;
    } catch(Throwable t) {
        throw new RuntimeException(t);
    }
}

Meine Frage lautet also: Gibt es eine weniger "hackige" Möglichkeit, dies mit Play zu tun (ich bin nicht dagegen, Scala und Java zu mischen, um dorthin zu gelangen), als den obigen Code zu kopieren? Ich hätte auch gerne die Möglichkeit gegeben, die Stapelaufrufe parallel oder nacheinander auszuführen ... Ich denke, nur einen zu instanziierenRoutes mit dem Klassenladeprogramm wäre das dann problematisch?