Java Sockets Source http java sun comdocsbookstutorialnetworkingsockets Reading

Java Sockets Source: http: //java. sun. com/docs/books/tutorial/networking/sockets/

Reading from and Writing to a Socket in Java • Let's look at a simple example that illustrates how a program can establish a connection to a server program using the Socket class and then, how the client can send data to and receive data from the server through the socket.

Echo Client • The example program implements a client, Echo. Client, that connects to the Echo server. The Echo server simply receives data from its client and echoes it back. The Echo server is a well-known service that clients can rendezvous with on port 7.

Echo Client description • Echo. Client creates a socket thereby getting a connection to the Echo server. It reads input from the user on the standard input stream, and then forwards that text to the Echo server by writing the text to the socket. The server echoes the input back through the socket to the client. The client program reads and displays the data passed back to it from the server:

Echo Client code import java. io. *; import java. net. *; public class Echo. Client { public static void main(String[] args) throws IOException { Socket echo. Socket = null; Print. Writer out = null; Buffered. Reader in = null; try { echo. Socket = new Socket("taranis", 7); out = new Print. Writer(echo. Socket. get. Output. Stream(), true); in = new Buffered. Reader(new Input. Stream. Reader( echo. Socket. get. Input. Stream())); } catch (Unknown. Host. Exception e) { System. err. println("Don't know about host: taranis. "); System. exit(1); } catch (IOException e) { System. err. println("Couldn't get I/O for " + "the connection to: taranis. "); System. exit(1); }

Echo Client code, cont’d Buffered. Reader std. In = new Buffered. Reader( new Input. Stream. Reader(System. in)); String user. Input; while ((user. Input = std. In. read. Line()) != null) { out. println(user. Input); System. out. println("echo: " + in. read. Line()); } } out. close(); in. close(); std. In. close(); echo. Socket. close(); }

Echo Client walkthrough Note that Echo. Client both writes to and reads from its socket, thereby sending data to and receiving data from the Echo server. Let's walk through the program and investigate the interesting parts.

Echo Client try block • The three statements in the try block of the main method are critical. These lines establish the socket connection between the client and the server and open a Print. Writer and a Buffered. Reader on the socket: echo. Socket = new Socket("taranis", 7); out = new Print. Writer(echo. Socket. get. Output. Stream(), true); in = new Buffered. Reader(new Input. Stream. Reader( echo. Socket. get. Input. Stream()));

echo. Socket = new Socket("taranis", 7); • The first statement in this sequence creates a new Socket object and names it echo. Socket. This Socket constructor requires the name of the machine and the port number to which you want to connect. This program uses the host name taranis. This is the name of a hypothetical machine on our local network. When you type in and run this program on your machine, change the host name to the name of a machine on your network. Make sure that the name you use is the fully qualified IP name of the machine to which you want to connect.

echo. Socket = new Socket("taranis", 7); • The second argument is the port number. Port number 7 is the port on which the Echo server listens.

out = new Print. Writer (echo. Socket. get. Output. Stream(), true); • The second statement gets the socket's output stream and opens a Print. Writer on it.

in = new Buffered. Reader(new Input. Stream. Reader( echo. Socket. get. Input. Stream())); • The third statement gets the socket's input stream and opens a Buffered. Reader on it. The example uses readers and writers so that it can write Unicode characters over the socket.

Sending Data • To send data through the socket to the server, Echo. Client simply needs to write to the Print. Writer. To get the server's response, Echo. Client reads from the Buffered. Reader. The rest of the program achieves this.

While Loop • The while loop reads a line at a time from the standard input stream and immediately sends it to the server by writing it to the Print. Writer connected to the socket: String user. Input; while ((user. Input = std. In. read. Line()) != null) { out. println(user. Input); System. out. println("echo: "+in. read. Line()); }

While Loop (continued) • The last statement in the while loop reads a line of information from the Buffered. Reader connected to the socket. The read. Line method waits until the server echoes the information back to Echo. Client. When readline returns, Echo. Client prints the information to the standard output.

While Loop (continued) • The while loop continues until the user types an end-ofinput character. That is, Echo. Client reads input from the user, sends it to the Echo server, gets a response from the server, and displays it, until it reaches the end-of-input. The while loop then terminates and the program continues, executing the next four lines of code: out. close(); in. close(); std. In. close(); echo. Socket. close();

Housekeeping out. close(); in. close(); std. In. close(); echo. Socket. close(); • These lines of code fall into the category of house keeping. A well-behaved program always cleans up after itself, and this program is well-behaved. These statements close the readers and writers connected to the socket and to the standard input stream, and close the socket connection to the server. The order here is important. You should close any streams connected to a socket before you close the socket itself.

Summary • This client program is straightforward and simple because the Echo server implements a simple protocol. The client sends text to the server, and the server echoes it back. When your client programs are talking to a more complicated server such as an HTTP server, your client program will also be more complicated.

The Basics • Open a socket. • Open an input stream and output stream to the socket. • Read from and write to the stream according to the server's protocol. • Close the streams. • Close the socket. • Only step 3 differs from client to client, depending on the server. The other steps remain largely the same.

Writing a Datagram Client and Server • The example featured in this section consists of two applications: a client and a server. The server continuously receives datagram packets over a datagram socket. Each datagram packet received by the server indicates a client request for a quotation. When the server receives a datagram, it replies by sending a datagram packet that contains a one-line "quote of the moment" back to the client.

Datagram Client / Server • The client application in this example is fairly simple. It sends a single datagram packet to the server indicating that the client would like to receive a quote of the moment. The client then waits for the server to send a datagram packet in response. • Two classes implement the server application: Quote. Server and Quote. Server. Thread. A single class implements the client application: Quote. Client.

The Quote. Server Class • The Quote. Server class, shown here in its entirety, contains a single method: the main method for the quote server application. The main method simply creates a new Quote. Server. Thread object and starts it: import java. io. *; public class Quote. Server { public static void main(String[] args) throws IOException { new Quote. Server. Thread(). start(); } }

The Quote. Server. Thread Class • When created, the Quote. Server. Thread class creates a Datagram. Socket on port 4445 (arbitrarily chosen). This is the Datagram. Socket through which the server communicates with all of its clients.

public Quote. Server. Thread() throws IOException { this("Quote. Server"); } public Quote. Server. Thread(String name) throws IOException { super(name); socket = new Datagram. Socket(4445); try { in = new Buffered. Reader( new File. Reader("oneliners. txt")); } catch (File. Not. Found. Exception e) System. err. println("Couldn't open quote file. " + "Serving time instead. "); } }

Ports • A computer usually has one physical connection to the network. So all the data from the network comes through this connection. • If all the data comes through the same interface how does the computer redirect to specific applications? • Recall, with IP network addresses – The computer is identified by its 32 -bit IP address – The port address is used to identify the specific program or application to send the packet to.

Ports • Port numbers range from 0 to 65, 535 because ports are represented by 16 -bit numbers. The port numbers ranging from 0 - 1023 are restricted. They are reserved for use by well-known services such as HTTP and FTP and other system services. • Remember that certain ports are dedicated to well-known services and you cannot use them. If you specify a port that is in use, the creation of the Datagram. Socket will fail. .

Constructor • The constructor also opens a Buffered. Reader on a file named oneliners. txt which contains a list of quotes. Each quote in the file is on a line by itself.

Run Method • Now for the interesting part of the Quote. Server. Thread: its run method. The run method overrides run in the Thread class and provides the implementation for the thread.

Run Method • The run method contains a while loop that continues as long as there are more quotes in the file. During each iteration of the loop, the thread waits for a Datagram. Packet to arrive over the Datagram. Socket. The packet indicates a request from a client. In response to the client's request, the Quote. Server. Thread gets a quote from the file, puts it in a Datagram. Packet and sends it over the Datagram. Socket to the client that asked for it.

Receive Request from Clients • Let's look first at the section that receives the requests from clients: byte[] buf = new byte[256]; Datagram. Packet packet = new Datagram. Packet(buf, buf. length); socket. receive(packet); • The first statement creates an array of bytes which is then used to create a Datagram. Packet.

Datagram. Packet • The Datagram. Packet will be used to receive a datagram from the socket because of the constructor used to create it. This constructor requires only two arguments: a byte array that contains client-specific data and the length of the byte array. When constructing a Datagram. Packet to send over the Datagram. Socket, you also must supply the Internet address and port number of the packet's destination. You'll see this later when we discuss how the server responds to a client request.

socket. receive(packet); • The last statement in the previous code snippet receives a datagram from the socket (the information received from the client gets copied into the packet). The receive method waits forever until a packet is received. If no packet is received, the server makes no further progress and just waits.

Server Responds to a Request • Now assume that, the server has received a request from a client for a quote. Now the server must respond. This section of code in the run method constructs the response: String d. String = null; if (in == null) d. String = new Date(). to. String(); else d. String = get. Next. Quote(); buf = d. String. get. Bytes();

Server Response (continued) • If the quote file did not get opened for some reason, then in equals null. If this is the case, the quote server serves up the time of day instead. Otherwise, the quote server gets the next quote from the already opened file. Finally, the code converts the string to an array of bytes.

Server Sends Response • Now, the run method sends the response to the client over the Datagram. Socket with this code: Inet. Address address = packet. get. Address(); int port = packet. get. Port(); packet = new Datagram. Packet(buf, buf. length, address, port); socket. send(packet);

Server Sends Response • The first two statements in this code segment get the Internet address and the port number, respectively, from the datagram packet received from the client. The Internet address and port number indicate where the datagram packet came from. This is where the server must send its response. In this example, the byte array of the datagram packet contains no relevant information. The arrival of the packet itself indicates a request from a client that can be found at the Internet address and port number indicated in the datagram packet.

Server Sends Response (continued) The third statement creates a new Datagram. Packet object intended for sending a datagram message over the datagram socket. You can tell that the new Datagram. Packet is intended to send data over the socket because of the constructor used to create it. This constructor requires four arguments. The first two arguments are the same required by the constructor used to create receiving datagrams: a byte array containing the message from the sender to the receiver and the length of this array. The next two arguments are different: an Internet address and a port number. These two arguments are the complete address of the destination of the datagram packet and must be supplied by the sender of the datagram. The last line of code sends the Datagram. Packet on its way.

Server Clean up • When the server has read all the quotes from the quote file, the while loop terminates and the run method cleans up: socket. close();

The Quote. Client Class • The Quote. Client class implements a client application for the Quote. Server. This application sends a request to the Quote. Server, waits for the response, and, when the response is received, displays it to the standard output. Let's look at the code in detail.

Local Variables • The Quote. Client class contains one method, the main method for the client application. The top of the main method declares several local variables for its use: int port; Inet. Address address; Datagram. Socket socket = null; Datagram. Packet packet; byte[] send. Buf = new byte[256];

Process Command Line Arguments • First, the main method processes the command-line arguments used to invoke the Quote. Client application: if (args. length != 1) { System. out. println("Usage: java Quote. Client <hostname>"); return; } • The Quote. Client application requires one commandline argument: the name of the machine on which the Quote. Server is running.

Create Socket • Next, the main method creates a Datagram. Socket: Datagram. Socket socket = new Datagram. Socket();

Create Socket, cont’d • The client uses a constructor that does not require a port number. This constructor just binds the Datagram. Socket to any available local port. It doesn't matter what port the client is connected to because the Datagram. Packets contain the addressing information. The server gets the port number from the Datagram. Packets and send its response to that port.

Client Request to Server • Next, the Quote. Client program sends a request to the server: byte[] buf = new byte[256]; Inet. Address address = Inet. Address. get. By. Name(args[0]); Datagram. Packet packet = new Datagram. Packet(buf, buf. length, address, 4445); socket. send(packet);

The code segment gets the Internet address for the host named on the command line (presumably the name of the machine on which the server is running). This Inet. Address and the port number 4445 (the port number that the server used to create its Datagram. Socket) are then used to create Datagram. Packet destined for that Internet address and port number. Therefore the Datagram. Packet will be delivered to the quote server.

Note that the code creates a Datagram. Packet with an empty byte array. The byte array is empty because this datagram packet is simply a request to the server for information. All the server needs to know to send a response--the address and port number to which reply--is automatically part of the packet.

Client Gets Response • Next, the client gets a response from the server and displays it: packet = new Datagram. Packet(buf, buf. length); socket. receive(packet); String received = new String(packet. get. Data()); System. out. println("Quote of the Moment: " + received);

Client Gets Response (continued) To get a response from the server, the client creates a "receive" packet and uses the Datagram. Socket receive method to receive the reply from the server. The receive method waits until a datagram packet destined for the client comes through the socket. Note that if the server's reply is somehow lost, the client will wait forever because of the no -guarantee policy of the datagram model. Normally, a client sets a timer so that it doesn't wait forever for a reply; if no reply arrives, the timer goes off and the client retransmits.

get. Data Method • When the client receives a reply from the server, the client uses the get. Data method to retrieve that data from the packet. The client then converts the data to a string and displays it.

Running the Server • After you've successfully compiled the server and the client programs, you run them. You have to run the server program first. Just use the Java interpreter and specify the Quote. Server class name.

Running the Client • Once the server has started, you can run the client program. Remember to run the client program with one command-line argument: the name of the host on which the Quote. Server is running.

Output • After the client sends a request and receives a response from the server, you should see output similar to this: Quote of the Moment: Good programming is 99% sweat and 1% coffee.

Multi-Threaded Server Skeleton File: KKmulti. Server. java import java. net. *; import java. io. *; public class KKMulti. Server { public static void main(String[] args) throws IOException { Server. Socket server. Socket = null; boolean listening = true; try { server. Socket = new Server. Socket(4444); } catch (IOException e) { System. err. println("Could not listen on port: 4444. "); System. exit(-1); }

Main Server Skeleton File: KKmulti. Server. java (continued) n Here is where all the main server “work” is performed. while (listening) new KKMulti. Server. Thread(server. Socket. accept()). start(); server. Socket. close(); } }

JAVA Classes for Networking URL, URLConnection, Server Socket, Inet. Address, and Socket Classes See Waite and Lafore, Object Oriented Programming in Java, chapter 16

URL • URL is an acronym for Uniform Resource Locator and is a reference (an address) to a resource on the Internet. It is comprised of the following components, Protocol : //java. sun. com

URL Class • Key Constructors URL(String url. Text) URL(URL base. URL, String url. Text)

URL Class • Key Public Methods boolean equals(Object obj) Object get. Content() String get. File() String get. Host() String get. Port() String get. Protocol() String get. Ref() URLConnection open. Connection Input. Stream open. Stream() boolean same. File(URL doc)

URLConnection Class • Key Public Methods void connect() Object get. Content() String get. Content. Encoding() int get. Content. Length() String get. Content. Type() long getexpiration() String get. Header. Field(String fieldname) String get. Header. Field(int n) get. Input. Stream() get. Last. Modified() URL get. URL()

Server Socket Class • Key Public Methods Socket accept() void close() inet. Address get. Inet. Address() int get. Local. Port()

Inet. Address Class • Key Public Class Methods Inet. Address[]get. All. By. Name(String Host) (returns array) Inet. Address get. By. Name(String Host) Inet. Address get. Local. Host() • Key Public Methods byte get. Address() String get. Host. Name()

Socket Class • Key Constructors Socket(String host, int port) Socket(Inet. Address ip. Number , int port) • Key Public Methods void close() Inet. Address get. Inet. Address() Input. Stream get. Input. Stream() int get. Local. Port() Output. Stream get. Output. Stream() int get(Port()

Most common problem in Java Setting Environment • If you are on an NT system where you do not have permission to modify autoexec. bat, you can set the class path for Java with • set classpath={your class location} • In most Windows systems, you can search Help for “environment variables” to find out how to set your classpath.

Applet problems • If you have trouble running your program in an applet, it may be because you have not set the display property. • The environment variable 'DISPLAY' tells UNIX where to display your windows. On a graphical workstation your DISPLAY value should be "computer_name: 0" where you use the name of the computer in front of which you're sitting. • Type setenv DISPLAY=chrome. njit. edu: 0 if your computer's name is chrome. njit. edu. • The format for setting the DISPLAY variable may vary depending on the SHELL you are using.