Re: serversocket

On 07/14/2012 07:56 AM, Lucyann Lenon Emerick De Assis wrote:


It's spelled "Java", not "java".


Actually, the code you show is riddled with bugs and potential bugs.

I don't know what you mean by "working", but it isn't what I mean.


Gave you the IP address of what server? How does another server demonstrate
the correctness of your code?


First, thank you for providing such a complete example. Not everyone does.
Those folks should take heed of

http://sscce.org/

You do tend to comment excessively, making note of things the code itself
already documents. For example:

         //Declaro o ServerSocket
         ServerSocket serv = null;

Well, duh! Comments should be helpful, not silly. They should express what the
code does not already make crystal clear.

I find the style of many consecutive blank lines at random points in the
source to be disconcerting at best. What is it intended to communicate?

Also, your variable names are too terse. 's' and 'serv' are not as good
variable names as 'socket' and 'serverSocket'.

         serverSocket = new ServerSocket(11000);

The value '11000' should be declared as a constant variable member, not
embedded deep in the code like this, an antipattern called "magic values".

         try
         {
           s.close();
           serv.close();
         }
         catch (IOException e)
         {
         }

Don't ever ignore exceptions like that! At an absolute minimum you must log them.

Note that if 's.close();' throws an exception, 'serv.close();' will not
execute. There's room for a bug there, in theory. (In practice I've never
heard of such a 'close()' call failing, but it could, I suppose.)

Furthermore, you coded these resource variables in such a way as to risk a
'NullPointerException' ("NPE"). This is a common consequence of initializing
resource variables to 'null' and ignoring the concomitant responsibility to
check for 'null' before calling methods on them. That's bad coding, for sure.

I find it safer to declare the variables 'final' and not initialize them to
'null' but to the desired resource reference in a separate 'try...catch'
block. That way you don't have to check for 'null' when you 'close()' them.
Doing what you did is begging for bugs.

You initialize the server socket every time through the loop. That is not
normal. You shouldn't create a new server socket every time you want to make a
connection; you should reuse the server socket and get a new regular socket
for each connection.

You should limit the scope of 'entrada' to the block that uses it. Declaring
variables with too wide a scope is an invitation for bugs, and an impediment
to the garbage collector.

I provide a rewrite taking these hints into account. As an exercise, you
should convert all the static methods except 'main()' into instance methods. I
gave you a head start.

The code compiles but I haven't run it.

Question: How does the client know to connect to this server?
Question: How will the client connect to this server?
Question: Please show us the client code.

/* Track
  * $RCSfile$
  */
package eegee;

/**
  * Track.
  */
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

import org.apache.log4j.Logger;

public class Track
{
   static final Logger logger = Logger.getLogger(Track.class);
   static final int PORT = 11000;
   static final int BAD_EXIT = -1;

   static final String BAD_SERVER_SOCKET = "Unable to establish ServerSocket";
   static final String BAD_CONNECT =
       "Algum problema ocorreu para criar ou receber o socket.";
   static final String BAD_GETSTREAM = "Unable to open InputStream";
   static final String BAD_READ = "Bad read from Socket";
   static final String BAD_CLOSE = "Failure in close() call";

   /**
    * Run the Track server.
    *
    * @param args String [] of command-line arguments.
    */
   public static void main(String[] args)
   {
     final ServerSocket serverSocket;
     try
     {
       serverSocket = new ServerSocket(PORT);
     }
     catch (IOException exc)
     {
       logger.error(BAD_SERVER_SOCKET, exc);
       System.exit(BAD_EXIT);
       return; // satisfy compiler that serverSocket was initialized
     }
     assert serverSocket != null;

     try
     {
       serveConnections(serverSocket);
     }
     finally
     {
       close(serverSocket);
     }
   }

   private static void serveConnections(ServerSocket serverSocket)
   {
     while (true)
     {
       final Socket connectionSocket;
       try
       {
         connectionSocket = serverSocket.accept();
       }
       catch (IOException exc)
       {
         logger.error(BAD_CONNECT, exc);
         return;
       }
       assert connectionSocket != null;

       try
       {
         handleClient(connectionSocket);
       }
       finally
       {
         close(connectionSocket);
       }
     }
   }

   private static void handleClient(Socket connectionSocket)
   {
     final BufferedReader entrada;
     try
     {
       entrada = new BufferedReader(new InputStreamReader(
           connectionSocket.getInputStream()));
     }
     catch (IOException exc)
     {
       logger.error(BAD_GETSTREAM, exc);
       return;
     }
     assert entrada != null;

     try
     {
       String request = entrada.readLine();
       handleRequest(request);
     }
     catch (IOException exd)
     {
       logger.error(BAD_READ, exd);
     }
     finally
     {
       close(entrada);
     }
   }

   private static void handleRequest(String request)
   {
     System.out.println(request);
   }

   static void close(Closeable closeable)
   {
     try
     {
       closeable.close();
     }
     catch (IOException exc)
     {
       logger.error(BAD_CLOSE, exc);
     }
   }

   static void close(Socket closeable)
   {
     try
     {
       closeable.close();
     }
     catch (IOException exc)
     {
       logger.error(BAD_CLOSE, exc);
     }
   }

   private final int port;

   /**
    * Instantiate with the default server port.
    */
   public Track()
   {
     this(PORT);
   }

   /**
    * Instantiate with the specified server port.
    * @param port int server port.
    */
   public Track(int port)
   {
     this.port = port;
   }

   public int getPort()
   {
     return port;
   }
}

--
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg