[JAVA] Introduction à Ratpack (5) --Json & Registry

Série d'introduction Ratpack

1. Introduction à Ratpack (1) - Qu'est-ce que Ratpack
2. Introduction à Ratpack (2) --Architecture
3. Introduction à Ratpack (3) - Explication détaillée de Hello world
4. Introduction à Ratpack (4) --Routage et contenu statique
5. Introduction à Ratpack (5) --Json & Registry
6. Introduction à Ratpack (6) - Promise
7. Introduction à Ratpack (7) --Guice & Spring
8. Introduction à Ratpack (8) - Session
9. Introduction à Ratpack (9) --Thymeleaf

Json

Ratpack a un support JSON intégré à l'aide de Jackson. JSON est disponible en standard et ne nécessite pas de module ratpack-jackson séparé.

Officiel

@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 ) );
}

(J'utilise lombok)

C'est facile à utiliser, enveloppez-le simplement dans chaque méthode de ratpack.jackson.Jackson. Objets Marshall / unmarshall via Jackson. Jackson.fromJson () peut être omis et remplacé par la partie commentée. Ceci est dû au fait que le NoOptParserSupport pour le moment où la classe brute` est passée est automatiquement ajouté.

Relation entre «Registry» et «Renderer», «Parser»

render () prend ʻObject comme argument, et parse () prend n'importe quelle classecomme argument. À ce stade, il est nécessaire de convertir «Object» en une réponse HTTP appropriée. [Comme je l'ai mentionné un peu plus tôt](https://qiita.com/minebreaker/items/b26d7d0677f91f17a7b5#handlers), cette conversion utilise les classesRenderer et Parser enregistrées dans le Registry`. Il sera converti de manière appropriée en étant appelé en fonction de la personne demandée. Par conséquent, vous pouvez réaliser votre propre conversion en enregistrant votre propre moteur de rendu personnalisé dans le registre.

Ici, à titre d'exemple, créons un mécanisme pour recevoir et renvoyer des données au format CSV. ʻUser` est le même que l'exemple ci-dessus.

Tout d'abord, définissez 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() );
    }
}

Il hérite du RendererSupport, qui est le squelette de l'interface Render. Lorsque Context.render () dans le gestionnaire est appelé avec ʻUser comme argument, ce moteur de rendu qui peut afficher la classe ʻUser est appelé. Les arguments sont le «Contexte» de la requête et l '«Utilisateur» passé à «render ()». Je pense que c'est presque ce que vous attendez. La méthode de sortie de la réponse est la même que lors de l'utilisation du gestionnaire.

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;
        }
    }
}

Comme le moteur de rendu, l'analyseur hérite du squelette NoOptParserSupport qui implémente l'interface Parser. NoOptParserSupport est utilisé pour fournir l'analyseur le plus simple, en particulier lorsque parse (Class) est appelé. Si TypeToken, c'est-à-dire que la personne demandée n'était pas ʻUser, renvoie null` pour indiquer que cet analyseur ne peut pas le gérer.

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 );
                } );
            } );
        } );
    }
}

Afin de montrer le comportement lors de l'inscription dans le registre, j'ai également essayé de faire du gestionnaire une classe distincte ici.

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 ) );
}

Vous devez enregistrer votre propre classe dans Registry. Notez que nous passons la méthode handler () à la Class, pas à l'instance.

Résultat d'exécution

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

J'ai pu confirmer que CSV a été traité via un moteur de rendu et un analyseur défini par moi-même.