verfügbare bytes im InputStream

Freak2k

Erfahrenes Mitglied
Hallo,

ich suche eine Möglichkeit rauszukriegen, wie viele bytes in einem Inputstream vorhanden sind.
Der Inputstream liegt "über" einem Socket.
Ich hoffe irgendwie um einen Puffer rumzukommen, der die daten zwischenspeichert.
So würde ich abfragen, ob die benötigte Menge daten da ist, bevor ich sie auslese.

m.f.G.
Freak
 
Hi,

glaube nicht, dass Du da um einen Puffer herumkommen wirst.

Mir ist leider auch nicht bekannt wie es ohne gehen soll.

Gruß

Romsl
 
Hallo!

Über die Methode available() kannst du an einem InputStream prüfen, wieviele Bytes maximal beim nächsten read(...) Zugriff verfügbar sind.

Ich frag mich auch, weshalb du keinen Buffer verwenden möchtest...?

Gruss Tom
 
die available() methode vom inputstream liefert immer 0 zurück...
wie baue ich mir einen solchen buffer am besten?
 
Kennt irgendjemand gute beispiele für einen solchen empfangspuffer?
Im prinzip wäre doch ein Stream denkbar, an dem ich hinten einzelne bytes oder byte arrays anfügen könnte und vorne immer weglesen (wie im nromalen inputstream).

wie realisiere ich den?
danke
 
Hallo!

Schau mal hier:
Code:
/**
 * 
 */
package de.tutorials;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Tom
 * 
 */
public class ClientServerFileTransferExample {

    static ExecutorService executorService = Executors.newCachedThreadPool();

    static int cnt;

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        executorService.execute(new Runnable() {
            public void run() {
                try {
                    final Server server = new Server(8888, new File("c:/tmp/jboss-4.0.3.zip"));
                    server.start();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        
        executorService.execute(new Runnable() {
            public void run() {
                try {
                    Client client = new Client("localhost", 8888);
                    client.start();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        
        executorService.execute(new Runnable() {
            public void run() {
                try {
                    Client client = new Client("localhost", 8888);
                    client.start();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

    }

    static class Client {
        Socket socket;

        public Client(String serverName, int port) throws Exception {
            this.socket = new Socket(serverName, port);
            System.out.println(this + " connected. --> " + this.socket.getLocalSocketAddress());
        }

        public void start() {
            try {
                System.out.println(this +  " started file transfer.");
                InputStream inputStream = this.socket.getInputStream();
                byte[] buffer = new byte[16384];
                int bytesRead;

                OutputStream outputStream = new FileOutputStream("c:/download/"
                        + (cnt++) + "_foo.dat");
                while ((bytesRead = inputStream.read(buffer)) > 0) {
                    outputStream.write(buffer, 0, bytesRead);
                }
                outputStream.flush();
                outputStream.close();
                socket.close();
                System.out.println(this +  " finished file transfer.");

            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    static class Server {
        ServerSocket serverSocket;

        File fileToServe;

        /**
         * @param port
         */
        public Server(int port, File fileToServe) throws Exception {
            serverSocket = new ServerSocket(port);
            this.fileToServe = fileToServe;
            System.out.println("Server ready.");
        }

        public void start() {
            while (true) {
                try {
                    System.out.println("Waiting for clients...");
                    final Socket socket = serverSocket.accept();
                    executorService.execute(new Runnable() {
                        public void run() {
                            System.out.println("Client: " + socket.getLocalSocketAddress() + " succesfully connected.");
                            try {
                                FileInputStream fileInputStream = new FileInputStream(
                                        fileToServe);
                                byte[] buffer = new byte[16384];
                                int bytesRead;

                                OutputStream outputStream = socket
                                        .getOutputStream();
                                while ((bytesRead = fileInputStream
                                        .read(buffer)) > 0) {
                                    outputStream.write(buffer, 0, bytesRead);
                                }
                                outputStream.flush();
                                outputStream.close();
                                socket.close();

                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

Code:
Server ready.
Waiting for clients...
de.tutorials.ClientServerFileTransferExample$Client@173a10f connected. --> /127.0.0.1:1748
de.tutorials.ClientServerFileTransferExample$Client@173a10f started file transfer.
Waiting for clients...
Client: /127.0.0.1:8888 succesfully connected.
de.tutorials.ClientServerFileTransferExample$Client@a62fc3 connected. --> /127.0.0.1:1749
de.tutorials.ClientServerFileTransferExample$Client@a62fc3 started file transfer.
Waiting for clients...
Client: /127.0.0.1:8888 succesfully connected.
de.tutorials.ClientServerFileTransferExample$Client@173a10f finished file transfer.
de.tutorials.ClientServerFileTransferExample$Client@a62fc3 finished file transfer.

... braucht bei mir so nur knapp 4 Sekunden für ~70MB und verbraucht dabei nie mehr als 8 MB Speicher...

Gruß Tom
 
soweit hab ich ja kein problem!

nur ich brauch immer eine bestimmte anzahl empfangender bytes, bevor ich sie verarbeiten kann!
angenommen ich brauch 1000bytes....hab aber nur 800 empfangen.
diese 800 will ich in einen puffer schieben und auf den rest warten.
jetzt kommen im zweiten durchlauf weitere 800 bytes (die restlichen 200 für erste "paket" und die ersten 600 fürs nächste)
Die müssen auch in den puffer.
jetzt hol ich mir die ersten 1000 aus dem puffer ...
und muss jetzt wieder warten, bis wieder genügend daten zur verarbeitung im puffer liegen.

wie realsiere ich diesen puffer?
 
Hallo!

Schau mal hier:
Code:
/**
 * 
 */
package de.tutorials;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author Tom
 * 
 */
public class ClientServerExample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.execute(new Runnable() {
            public void run() {
                try {
                    Socket socket = new ServerSocket(8888).accept();

                    OutputStream outputStream = socket.getOutputStream();
                    byte[] buffer = new byte[2048];
                    while (true) {
                        System.out.println("Server: writing " + buffer.length +" bytes to the outputstream." );
                        outputStream.write(buffer);
                        outputStream.flush();
                        TimeUnit.SECONDS.sleep(1L);
                    }
                    //outputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        executorService.execute(new Runnable() {
            public void run() {
                try {
                    Socket socket = new Socket("localhost",8888);

                    InputStream inputStream = socket.getInputStream();
                    byte[] buffer = new byte[1024];
                    int bytesRead;
                    ByteArrayOutputStream baos = new ByteArrayOutputStream(10240);
                    
                    while((bytesRead = inputStream.read(buffer))>0){
                        System.out.println("Client: read " + bytesRead + " from inputstream");
                        baos.write(buffer,0,bytesRead);
                        
                        int processBufferSize = baos.size();
                        System.out.println("Client: ProcessBufferSize " + processBufferSize);
                        if(processBufferSize == 10240){
                            processBytes(baos.toByteArray());
                            baos.reset();
                        }
                    }
                    
                    inputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            private void processBytes(byte[] bs) {
                System.out.println("Processing: " + bs.length+ " bytes.");
            }
        });
        
    }
}

Gruß Tom
 
Hab mal ne frage. Und zwar schicke ich per iPhone ein .jpeg auf dem Server. Und schreibt das dann als file auf den server. Jetzt habe ich die zwei .jpeg verglichen und muss feststellen, dass die .jpeg grösser auf dem server grösser ist als die original .jpeg.

Woran könnte das liegen?
 
Zurück