InputStream à servletInputStream

Mon conseil: ne pas créer la ByteArrayInputStream, il suffit d'utiliser le tableau d'octets que vous avez obtenu à partir de la getBytes méthode déjà. Cela devrait être suffisant pour créer un ServletInputStream.

Plus solution de base

Malheureusement, aksappy la réponse de l'remplace uniquement les read méthode. Alors que cela peut être suffisant dans le Servlet API 3.0 et ci-dessous, dans les versions ultérieures de Servlet API il y a trois plus de méthodes que vous avez à mettre en œuvre.

Voici mon implémentation de la classe, même si avec il devient assez long (en raison des nouvelles méthodes introduites dans l'API Servlet 3.1), vous voudrez peut-être penser à l'affacturage dans une imbriquées ou même de haut niveau de classe.

    final byte[] myBytes = myString.getBytes("UTF-8");
ServletInputStream servletInputStream = new ServletInputStream() {
private int lastIndexRetrieved = -1;
private ReadListener readListener = null;
@Override
public boolean isFinished() {
return (lastIndexRetrieved == myBytes.length-1);
}
@Override
public boolean isReady() {
//This implementation will never block
//We also never need to call the readListener from this method, as this method will never return false
return isFinished();
}
@Override
public void setReadListener(ReadListener readListener) {
this.readListener = readListener;
if (!isFinished()) {
try {
readListener.onDataAvailable();
} catch (IOException e) {
readListener.onError(e);
}
} else {
try {
readListener.onAllDataRead();
} catch (IOException e) {
readListener.onError(e);
}
}
}
@Override
public int read() throws IOException {
int i;
if (!isFinished()) {
i = myBytes[lastIndexRetrieved+1];
lastIndexRetrieved++;
if (isFinished() && (readListener != null)) {
try {
readListener.onAllDataRead();
} catch (IOException ex) {
readListener.onError(ex);
throw ex;
}
}
return i;
} else {
return -1;
}
}
};

L'ajout prévu méthodes

En fonction de vos besoins, vous pouvez également remplacer les autres méthodes. Comme romfret l'a souligné, il est conseillé de remplacer certaines méthodes, telles que close et available. Si vous n'avez pas à les mettre en œuvre, le flux sera toujours le rapport qu'il y a 0 octets disponible pour la lecture, et la close méthode ne modifient en rien l'état de flux. Vous pouvez probablement vous en sortir sans écraser skip, comme le défaut de mise en œuvre sera juste appeler read un certain nombre de fois.

    @Override
public int available() throws IOException {
return (myBytes.length-lastIndexRetrieved-1);
}
@Override
public void close() throws IOException {
lastIndexRetrieved = myBytes.length-1;
}

L'écriture d'une meilleure méthode close

Malheureusement, en raison de la nature de la classe anonyme, ça va être difficile pour vous d'écrire un efficace close méthode parce que tant qu'une instance du flux n'a pas été garbage collector de Java, il maintient une référence vers le tableau d'octets, même si le flux a été fermé.

Toutefois, si vous facteur de la classe dans une imbriquées ou haut-niveau de la classe (ou même une classe anonyme avec un constructeur qui vous appelez à partir de la ligne dans laquelle elle est définie), la myBytes peut être un non-finale de champ plutôt qu'une dernière variable locale, et vous pouvez ajouter une ligne comme:

myBytes = null;

à votre close méthode, qui va permettre à Java pour libérer de la mémoire prise par le tableau d'octets.

Bien sûr, cela va vous obliger à écrire un constructeur, tels que:

    private byte[] myBytes;
public StringServletInputStream(String str) {
try {
myBytes = str.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("JVM did not support UTF-8", e);
}
}

Marque et Réinitialiser

Vous pouvez également remplacer mark, markSupported et reset si vous voulez soutenir marque/reset. Je ne suis pas sûr si elles sont jamais appelés par votre contenant.

    private int readLimit = -1;
private int markedPosition = -1;
@Override
public boolean markSupported() {
return true;
}
@Override
public synchronized void mark(int readLimit) {
this.readLimit = readLimit;
this.markedPosition = lastIndexRetrieved;
}
@Override
public synchronized void reset() throws IOException {
if (markedPosition == -1) {
throw new IOException("No mark found");
} else {
lastIndexRetrieved = markedPosition;
readLimit = -1;
}
}
//Replacement of earlier read method to cope with readLimit
@Override
public int read() throws IOException {
int i;
if (!isFinished()) {
i = myBytes[lastIndexRetrieved+1];
lastIndexRetrieved++;
if (isFinished() && (readListener != null)) {
try {
readListener.onAllDataRead();
} catch (IOException ex) {
readListener.onError(ex);
throw ex;
}
readLimit = -1;
}
if (readLimit != -1) {
if ((lastIndexRetrieved - markedPosition) > readLimit) {
//This part is actually not necessary in our implementation
//as we are not storing any data. However we need to respect
//the contract.
markedPosition = -1;
readLimit = -1;
}
}
return i;
} else {
return -1;
}
}

OriginalL'auteur Kidburla