使用套接字将文件客户端发送到java中的服务器

Question

我试图在java中使用socket传输文件，在这里有一个Server.java，它等待请求，客户端将文件名传输到服务器，然后客户端将文件传输到服务器。

我很难用writeUTF编写Client.java，如果有人可以帮助我，我将非常感激

Server.java

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

public class ServidorFicheros {
    public static final int LONGITUDTROZO = 20;
    public static final int MAXNOMBREFICHERO = 256;
    public static final int PUERTOSERVIDOR = 35557;
    public static final int TAMFICHERO = 4; // Indica el n˙mero de bytes que se van a
                                            // recibir cuando el cliente envÌe al
                                            // el tamaÒo del fichero.


    public static void main(String args[]) {

        // leidos indica el n˙mero de bytes recibidos en un paquete de datos.
        // contador indica el n˙mero de bytes del fichero recibido.
        int leidos, contador = 0;

        // Fichero en el que se van a guardar los bytes recibidos. 
        BufferedOutputStream filtroDestino = null;

        // Elementos de comunicaciÛn: socket y paquete (objeto que se usa
        // para transmitir datos a travÈs de la red, incluye los datos en
        // sÌ, la longitud de los mismso y la direcciÛn destino (IP + puerto UDP)).
        DatagramSocket socket = null;
        DatagramPacket paquete = null;

        // almacen es un array en el que se almacenan los bytes recibidos a travÈs de la red.
        byte almacen[];

        // Nombre del fichero en el que se va a guardar el fichero enviado por el cliente. 
        String nombreFichero = null;

        // respuesta indica si el usuario quiere o no recibir otro fichero.
        String respuesta = null;
        Scanner teclado = new Scanner( System.in );

        // DirecciÛn IP del cliente y puerto del cliente.
        InetAddress dirIPCliente = null;
        int puertoCliente = 0;

        try {

            //CreaciÛn del socket. El servidor usar· un puerto UDP
            // concreto, ya que los clientes "llamar·n" a ese puerto.
            socket = new DatagramSocket(PUERTOSERVIDOR);

            System.out.println( "Servidor arrancado...");

            do{
                contador = 0;

                // RecepciÛn del nombre del fichero.
                // El cliente va a enviar el nombre de fichero como una secuencia de
                // bytes. El cliente usar· el mÈtodo writeUTF de la clase
                // java.io.DataOutputStream para ello. Dicho mÈtodo representa una secuencia 
                // de caracteres mediante 2 bytes iniciales que indican la longitud en 
                // caracteres del nombre del fichero y a continuaciÛn tantos bytes como
                // caracteres; cada caracter se representar· mediante un byte.
                almacen = new byte[MAXNOMBREFICHERO + 2];
                paquete = new DatagramPacket( almacen, almacen.length );

                System.out.println("\nEsperando peticiÛn del cliente...");
                socket.receive(paquete);
                dirIPCliente = paquete.getAddress();
                puertoCliente = paquete.getPort();

                ByteArrayInputStream bais = new ByteArrayInputStream( almacen );
                DataInputStream dis = new DataInputStream( bais );

                nombreFichero = dis.readUTF();
                System.out.println("Recibiendo el fichero "+
                                    nombreFichero+" de "+dirIPCliente.getHostName()+":"+puertoCliente);

                // Open the file destination (copy)
                filtroDestino = new BufferedOutputStream(new FileOutputStream(nombreFichero));


                almacen = new byte[LONGITUDTROZO];
                paquete.setData(almacen);
                paquete.setLength(LONGITUDTROZO);
                do {
                    socket.receive(paquete);
                    leidos = paquete.getLength();
                    contador += leidos;
                    if (leidos > 0) 
                        filtroDestino.write(almacen,0,leidos);
                } 
                while (leidos == LONGITUDTROZO);
                // if leidos > 0  exists ultimotrozo<LONGITUDTROZO
                // if leidos == 0,file is multiple of LONGITUDTROZO

                //Close file
                filtroDestino.close();
                almacen = new byte[TAMFICHERO];

                //receive number of bytes
                paquete.setData(almacen);
                paquete.setLength(almacen.length);

                socket.receive(paquete);

                bais = new ByteArrayInputStream( almacen );
                dis = new DataInputStream( bais );

                int tamFichero = dis.readInt();

                if ( tamFichero == contador )
                    System.out.println( "Recibido el fichero "+nombreFichero+" de "+contador+" bytes.");
                else{
                    File fichero = new File(nombreFichero);
                    fichero.delete();
                    System.out.println( "Errores al recibir el fichero "+nombreFichero );
                }
                System.out.print("\nRecibir otro fichero? " );
                respuesta = teclado.nextLine();
            }while( respuesta.equalsIgnoreCase("S"));

        } 
        catch (FileNotFoundException e) {
            System.out.println("Apertura fichero: " + e.getMessage());
            e.printStackTrace();
        }catch (SocketException e) {
            System.out.println( "Error al abrir socket: "+e.getMessage());
            e.printStackTrace();
        } 
        catch (IOException e) {
            System.out.println("Recibir: " + e.getMessage());
            e.printStackTrace();
        }
        catch (SecurityException e) {
            System.out.println("Apertura fichero (permisos): " + e.getMessage());
            e.printStackTrace();
        } 
        finally { //close
            teclado.close();
        }
    }
}

Client.java

public class ClienteFicheros
{


    public void ClienteFicheros(String fichero, String servidor, int puerto)
    {
        try
        {
            Socket socket = new Socket(servidor);
            String pathname = fichero;
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            outputStream.writeUTF(pathname);
            FileInputStream fis = new FileInputStream(pathname);



    }

    public static void main(string args[])
    {
     ClienteFichero cf = new ClienteFichero();
     cf.ClienteFicheros(args[1], "localhost", 3000);
    }

}