[JAVA] Einführung in Ratpack (5) --Json & Registry

Ratpack Einführungsserie

Json

Ratpack verfügt über eine integrierte JSON-Unterstützung mit Jackson. JSON ist standardmäßig verfügbar und erfordert kein separates "ratpack-jackson" -Modul.

Offiziell

@Data
@AllArgsConstructor
@NoArgsConstructor
public static final class User {
    private int id;
    private String name;
}

public static void main( String[] args ) throws Exception {

    Action<Chain> handlers = chain -> {
        chain.all( ctx -> {
            ctx.byMethod( m -> {
                m.get( iCtx -> iCtx.render( Jackson.json( new User( 123, "John" ) ) ) );
                m.post( iCtx -> iCtx.parse( Jackson.fromJson( User.class ) ).then( user -> {
                    iCtx.render( "Received user: " + user );
                } ) );
                //　m.post( iCtx -> iCtx.parse( User.class ).then( user -> {
                //  　  iCtx.render( "Received user: " + user );
                //　} ) );
            } );
        } );
    };

    RatpackServer.start( server -> server
            .serverConfig( ServerConfig.builder().development( true ).build() )
            .handlers( handlers ) );
}

(Ich benutze lombok)

Es ist einfach zu bedienen, wickeln Sie es einfach in jede Methode von ratpack.jackson.Jackson ein. Marshall / Unmarshall Objekte durch Jackson. Jackson.fromJson () kann weggelassen und durch den auskommentierten Teil ersetzt werden. Dies liegt daran, dass der "NoOptParserSupport" für das Übergeben der rohen "Klasse" automatisch hinzugefügt wird.

Beziehung zwischen "Registry" und "Renderer", "Parser"

render () nimmt Object als Argument und parse () nimmt jede Klasse als Argument. Zu diesem Zeitpunkt ist es erforderlich, von "Objekt" in eine geeignete HTTP-Antwort zu konvertieren. Wie ich bereits erwähnt habe verwendet diese Konvertierung die in der Registrierung registrierten Klassen "Renderer" und "Parser". Es wird entsprechend konvertiert, indem es entsprechend der angeforderten Person angerufen wird. Daher können Sie Ihre eigene Konvertierung erzielen, indem Sie Ihren eigenen benutzerdefinierten Renderer in der Registrierung registrieren.

Hier erstellen wir als Beispiel einen Mechanismus zum Empfangen und Zurückgeben von Daten in CSV. User ist das gleiche wie im obigen Beispiel.

Definieren Sie zunächst "Renderer".

public static final class UserRenderer extends RendererSupport<User> {
    @Override
    public void render( Context ctx, User user ) throws Exception {
        ctx.getResponse().contentType( "text/plain" );
        ctx.render( user.getId() + "," + user.getName() );
    }
}

Es erbt von RendererSupport, dem Grundgerüst der Render-Schnittstelle. Wenn "Context.render ()" im Handler mit "User" als Argument aufgerufen wird, wird dieser Renderer aufgerufen, der die "User" -Klasse ausgeben kann. Die Argumente sind der "Kontext" der Anfrage und der "Benutzer", der an "render ()" übergeben wird. Ich denke, es ist fast so, wie Sie es erwarten würden. Die Methode zur Ausgabe der Antwort ist dieselbe wie bei Verwendung des Handlers.

public static final class UserParser extends NoOptParserSupport {
    @Override
    protected <T> T parse( Context context, TypedData requestBody, TypeToken<T> type ) throws Exception {
        if ( type.getRawType().equals( User.class ) ) {
            String[] csv = requestBody.getText().split( "," );
            User user = new User( Integer.parseInt( csv[0] ), csv[1] );
            return Types.cast( user );
        } else {
            return null;
        }
    }
}

Wie der Renderer erbt der Parser das Skelett "NoOptParserSupport", das die Schnittstelle "Parser" implementiert. "NoOptParserSupport" wird verwendet, um den einfachsten Parser bereitzustellen, insbesondere wenn "parse (Class)" aufgerufen wird. Wenn "TypeToken", dh die angeforderte Person, nicht "Benutzer" ist, wird "null" zurückgegeben, um anzuzeigen, dass dieser Parser nicht damit umgehen kann.

public static final class CustomHandler implements Handler {
    @Override
    public void handle( Context ctx ) throws Exception {
        ctx.byMethod( m -> {
            m.get( iCtx -> {
                iCtx.render( new User( 123, "John" ) );
            } );
            m.post( iCtx -> {
                iCtx.parse( User.class ).then( user -> {
                    iCtx.render( "Received: " + user );
                } );
            } );
        } );
    }
}

Um das Verhalten bei der Registrierung in der Registrierung zu zeigen, habe ich auch versucht, den Handler hier zu einer separaten Klasse zu machen.

public static void main( String[] args ) throws Exception {
    RatpackServer.start( server -> server
            .serverConfig( ServerConfig.builder().development( true ) )
            .registryOf( spec -> {
                spec.add( new UserRenderer() )
                    .add( new UserParser() )
                    .add( new CustomHandler() );
            } )
            .handler( CustomHandler.class ) );
}

Sie müssen Ihre eigene Klasse in "Registrierung" registrieren. Beachten Sie, dass wir die handler () Methode an die Class übergeben, nicht an die Instanz.

Ausführungsergebnis

$ curl localhost:5050 && echo
123,John
$ curl -X POST localhost:5050 --data "456,Jack" && echo
Received: Sample5_2_Registry.User(id=456, name=Jack)

Ich konnte bestätigen, dass CSV über einen von mir definierten Renderer und Parser verarbeitet wurde.