Arquivo Discussoes de Programacao e Tecnologia Seguinte galera…
Tenho esse trechinho de código:
out = new BufferedOutputStream(client.getOutputStream());
Preciso saber se tem alguma forma de eu “ver” os dados que estão dentro do out… tipo trasformar em String ou coisa parecida.
Agradeço a ajuda!
Não…
out.toString();
me retorna uma string que “representa” o objeto, tipo out.OutPutStream@213354646546. O que to precisando e enxergar os dados.
por ex: no InPutStream, vc tem o método read() que te ler verificar o conteúdo do mesmo, no out não.
Só que meu problema é justamente esse, preciso “enxergar” o que o usuário vai mandar pra servidor, e não o que recebe.
Mas valeu a intenção
Olá
Solução rápida:
Criar uma classe extensão de BufferedOutputStream adicionando métodos que permitem ver o conteúdo do buffer, o seu tamanho e ainda um toString para mostrar o buffer como String (opcionalmente com a opção de traduzir os bytes em caracteres de acordo com o character encoding especificado.
import java.io.*;
public class MyBufferedOutputStream extends BufferedOutputStream {
public MyBufferedOutputStream (OutputStream out) {
this(out, 8192);
}
public MyBufferedOutputStream (OutputStream out, int size) {
super(out, size);
}
public synchronized byte[] toByteArray () {
byte newbuf[] = new byte[super.count];
System.arraycopy(super.buf, 0, newbuf, 0, super.count);
return newbuf;
}
public int size () {
return super.count;
}
public String toString () {
return new String(super.buf, 0, super.count);
}
public String toString (String enc) throws UnsupportedEncodingException {
return new String(super.buf, 0, super.count, enc);
}
}
Bom proveito, mas me avise se funcionou porque eu não testei.
[]s
Luca
Às vezes preciso desse tipo de coisa para depuração. Então encapsulo a saída em um TeeOutputStream, cujo construtor recebe uma segunda OutputStream para ter uma "cópia" dos dados sendo processados.
A mesma coisa vale para a entrada.
Estude as classes FilterInputStream e FilterOutputStream para descobrir como é que isso funciona, e o comando "tee" do Unix/Linux. (Chame o comand "man tee" para a documentação desse comando)
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* Usado para depuração, para poder fazer uma análise da saída.
*/
public class TeeOutputStream extends FilterOutputStream {
/**
* Construtor.
* @param pOut A OutputStream.
*/
protected TeeOutputStream(OutputStream pOut) {
super(pOut);
}
/** OutputStream onde iremos jogar uma cópia da saída. */
private OutputStream out2;
/**
* Construtor.
* @param pOut O OutputStream que será 'wrapped'.
* @param pOut2 O OutputStream onde iremos jogar uma cópia da saída.
*/
public TeeOutputStream (OutputStream pOut, OutputStream pOut2) {
super (pOut);
out2 = pOut2;
}
/**
* @see java.io.FilterOutputStream#close()
*/
public void close() throws IOException {
out2.close();
super.close();
}
/**
* @see java.io.FilterOutputStream#flush()
*/
public void flush() throws IOException {
out2.flush();
super.flush();
}
/**
* @see java.io.FilterOutputStream#write(byte[], int, int)
*/
public void write(byte[] pB, int pOff, int pLen) throws IOException {
out2.write(pB, pOff, pLen);
super.write(pB, pOff, pLen);
}
/**
* @see java.io.FilterOutputStream#write(byte[])
*/
public void write(byte[] pB) throws IOException {
out2.write(pB);
super.write(pB);
}
/**
* @see java.io.FilterOutputStream#write(int)
*/
public void write(int pB) throws IOException {
out2.write(pB);
super.write(pB);
}
}
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Usado para depuração, para poder fazer uma análise da entrada.
*/
public class TeeInputStream extends FilterInputStream {
/**
* Construtor.
* @param pIn A InputStream.
*/
protected TeeInputStream(InputStream pIn) {
super(pIn);
}
/**
* Onde iremos jogar uma cópia da entrada.
*/
private OutputStream out;
/**
* Construtor.
* @param pIn A InputStream que será 'wrapped'.
* @param pOut A OutputStream onde iremos jogar uma cópia da saída.
*/
public TeeInputStream (InputStream pIn, OutputStream pOut) {
super (pIn);
out = pOut;
}
/**
* @see java.io.FilterInputStream#read()
*/
public int read() throws IOException {
int byt = super.read();
out.write(byt);
return byt;
}
/**
* @see java.io.FilterInputStream#read(byte[], int, int)
*/
public int read(byte[] pB, int pOff, int pLen) throws IOException {
int nBytes = super.read(pB, pOff, pLen);
if (nBytes > 0) {
out.write(pB, pOff, nBytes);
}
return nBytes;
}
/**
* @see java.io.FilterInputStream#read(byte[])
*/
public int read(byte[] pB) throws IOException {
int nBytes = super.read(pB);
if (nBytes > 0) {
out.write(pB, 0, nBytes);
}
return nBytes;
}
/**
* @see java.io.FilterInputStream#close()
*/
public void close() throws IOException {
out.close();
super.close();
}
}
Valeu pessoal…
Vou testar aqui e posto resultado!
out.toString() não te ajuda??
Returns a string representation of the object.
In general, the toString method returns a string that
"textually represents" this object.
The result should be a concise but informative
representation that is easy for a person to read.
It is recommended that all subclasses override this method.
Returns:
a string representation of the object.
sendAbraços();