jersey - StreamingOutput comme entité de Réponse

J'avais mis en œuvre streaming sortie dans mon Maillot de classe de Ressources.

@GET
@Path("xxxxx")
@Produces(BulkConstants.TEXT_XML_MEDIA_TYPE})   
public Response getFile() {

    FeedReturnStreamingOutput sout = new FeedReturnStreamingOutput();
    response = Response.ok(sout).build();
    return response;
}

class FeedReturnStreamingOutput implements StreamingOutput {

    public FeedReturnStreamingOutput()

    @Override
    public void write(OutputStream outputStream)  {
        //write into Output Stream
    }
}

Le problème est que même si une réponse est envoyée à partir de la ressource avant FeedReturnStreamingOutput est appelé Jersey client attend jusqu'à ce que FeedReturnStreamingOutput exécution est terminée.

Code Client :

Client client = Client.create();

ClientResponse response = webResource
    //headers
    .get(ClientResponse.class);

//The codes underneath executes after FeedReturnStreamingOutput is executed which undermines the necessity of streaming

OutputStream os = new FileOutputStream("c:\\test\\feedoutput5.txt");
System.out.println(new Date() + " : Reached point A");

if (response.getStatus() == 200) {
    System.out.println(new Date() + " : Reached point B");
    InputStream io = response.getEntityInputStream();

    byte[] buff = new byte[1024000];
    int count = 0;

    while ((count = io.read(buff, 0, buff.length)) != -1) {
        os.write(buff, 0, count);
    }

    os.close();
    io.close();

} else {
    System.out.println("Response code :" + response.getStatus());
}

System.out.println("Time taken -->> "+(System.currentTimeMillis()-startTime)+" ms");

OriginalL'auteur PrabhaT | 2015-04-14

27

Le problème est la mise en mémoire tampon OutputStream que Jersey utilise pour le tampon de l'entité afin de déterminer le Contenu de l'en-tête de Longueur. La taille de la mémoire tampon par défaut à 8 ko. Vous désactiver la mise en mémoire tampon si vous le souhaitez, ou tout simplement de changer la taille de la mémoire tampon, avec la propriété

ServerProperties.OUTBOUND_CONTENT_LENGTH_BUFFER

Une valeur entière qui définit la taille de la mémoire tampon de serveur-côté de la réponse de l'entité pour déterminer sa taille et définir la valeur de l'adresse HTTP "Content-length" (Longueur d'en-tête.

Si l'entité de la taille dépasse la configuration de la taille de la mémoire tampon, le tampon serait annulée et la taille des entités ne serait pas déterminée. Valeur inférieure ou égale à zéro désactiver la mise en mémoire tampon de l'entité.

Cette propriété peut être utilisée sur le serveur pour remplacer le message sortant taille de la mémoire tampon de la valeur par défaut ou personnalisée globale de la valeur définie à l'aide de la "jersey.config.contentLength.tampon" mondiale de la propriété.

La valeur par défaut est de 8192.

Voici un exemple
```
@Path("streaming")
public class StreamingResource {

    @GET
    @Produces("application/octet-stream")
    public Response getStream() {
        return Response.ok(new FeedReturnStreamingOutput()).build();
    }

    public static class FeedReturnStreamingOutput implements StreamingOutput {

        @Override
        public void write(OutputStream output)
                throws IOException, WebApplicationException {
            try {
                for (int i = 0; i < 10; i++) {
                    output.write(String.format("Hello %d\n", i).getBytes());
                    output.flush();
                    TimeUnit.MILLISECONDS.sleep(500);
                }
            } catch (InterruptedException e) {  throw new RuntimeException(e); }
        }
    }
}
```
Voici le résultat sans la définition de la propriété

Et voici le résultat après le réglage de la valeur de la propriété à 0
```
public class AppConfig extends ResourceConfig {
    public AppConfig() {
        ...
        property(ServerProperties.OUTBOUND_CONTENT_LENGTH_BUFFER, 0);
    }
}
```
C'est une excellente solution. Un truc que j'ai trouvé tout à l'heure - cela ne fonctionne que si vous avez un caractère de saut de ligne à la fin de votre saisie 🙂
Tu veux dire sans réglage OUTBOUND_CONTENT_LENGTH_BUFFER = 0 nous ne pouvons pas réellement flux quoi que ce soit ? c'est à dire si nous la mémoire tampon à 0, il serait tampon toutes dans la mémoire, puis rincer ça ? (ce qui pourrait causer de la mémoire hors limite si la réponse est grande)

OriginalL'auteur Paul Samsotha
1

Essayez d'appeler outputStream.flush() de la méthode FeedReturnStreamingOutput.write(...) tous les X nombre d'octets écrits dans le flux de sortie ou quelque chose comme ça.

Je suppose que le tampon de la connexion n'est pas remplie avec les données que vous retournez. Afin que le service ne retourne rien jusqu'à ce Maillot appelle outputStream.close().

Dans mon cas, j'ai un service qui enregistre les données et je suis en train de faire exactement comme vous: en retournant Response.ok(<instance of StreamingOutput>).build();.

Mes retours de service de données à partir d'une base de données et j'invoque outputStream.flush() après l'écriture de chaque ligne dans le flux de sortie.

Je sais que le service de flux de données parce que je peux voir le client commence à recevoir des données avant que le service a terminé l'envoi de l'ensemble de la suite.

J'ai ajouté outputstream.rincer à chaque fois que j'écris dans le flux de sortie. N'a pas fait toute la différence
Comment savez-vous que le service n'est pas en streaming? Se pourrait-il que le service est en train de diffuser les données, mais le client n'est pas écrit, ce qu'il obtient en streaming?

OriginalL'auteur Montecarlo
1

Soit votre réponse est trop petit et n'est jamais chunked de sorte que le serveur bouffées de chaleur de l'ensemble de la requête à la fois. Ou vous avez un problème côté serveur ont été vos jax-rs de la bibliothèque est en attente d'avoir le flux avant de rincer.

Cependant, cela ressemble plus à un client de problème. Et vous semblez être en utilisant une ancienne version de jersey-client.

Également que .get(ClientResponse.class) regarde poisson.

Essayez d'utiliser le JAX-RS standard tel qu'il est aujourd'hui (au moins dans le client):
```
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;

Client client = ClientBuilder.newBuilder().build();
WebTarget target = client.target("http://localhost:8080/");
Response response = target.path("path/to/resource").request().get();
```
Tout en ayant jersey client 2.17 dans le classpath:
```
<dependency>
    <groupId>org.glassfish.jersey.core</groupId>
    <artifactId>jersey-client</artifactId>
    <version>2.17</version>
</dependency>
```
OriginalL'auteur Daniel Sperry
0

Je viens de réaliser que si vous utilisez une sous-classe de StreamingOutput, Maillot n'est pas de flux de la réponse:
```
//works fine
Response.ok(new StreamingOutput() { ... }).build();

//don't work
public interface MyStreamingOutput extends StreamingOutput { }
Response.ok(new MyStreamingOutput() { ... }).build();
```
Est qu'un Maillot de bug?

Que voulez-vous dire "comme prévu"?
Je voulais le flux de la réponse. Je vais mettre à jour la réponse.
Je ne pense pas que ce soit le problème. Tous les l'auteur ne fait qu'appeler votre write méthode de passage dans l'entité OutputStream. Rien d'autre de spécial. Le streaming de problème avec la mise en mémoire tampon du flux de sortie Jersey utilise pour compter la Longueur du Contenu. Vous pouvez désactiver cette fonction avec cette propriété mis à 0.
C'est bizarre. Lorsque vous utilisez une sous-classe, l' isWriteable ne comprend pas que la classe est un StreamingOutput sous-type. Je peux reproduire ce comportement. Dois-je créer un cas de test pour le démontrer?
Quelle version utilisez-vous? En regardant la source la plus récente, il utilise StreamingOutput.class.isAssignableFrom(t);. Une sous-classe correspond à cette condition. Vous pouvez voir la réponse que je viens de poster. Testé avec la dernière version. Aussi loin que je me souvienne je n'ai jamais eu la sous-classe de problème avec les versions précédentes, soit

OriginalL'auteur Mike Dias

Vous devez vous connecter pour publier un commentaire.