Thread: Java TCP multiple clients

network.rar

In a screening I was asked to write a code for tcp connection supporting multiple clients. The code works, but my code was rejected bcoz it wasn't efficient.

Let me know, whats wrong.

thanks

package com.test.network;
/*  The java.net package contains the basics needed for network operations. */
import java.net.*;
import java.util.ResourceBundle;
import java.io.*;
 
import org.apache.log4j.Logger;
 
public class SocketClient {
 
	private static final Logger logger = Logger.getLogger(SocketClient.class);
	private static ResourceBundle resources = ResourceBundle.getBundle("socket");
 
	public static void main(String[] args) {
	    String host = "";
	    String encoding = "";
	    int port; 
	    StringBuffer instr = new StringBuffer();
	    String fileID = "1000";
 
	    try {
	    	host=resources.getString("host");
	    	port=new Integer(resources.getString("port")).intValue();
 
	    	encoding=resources.getString("encoding");
	    	logger.debug("file idnetifier:" + args[0]);
	    	/** Obtain an address object of the server */
	        InetAddress address = InetAddress.getByName(host);
	        logger.debug("Inet Address" + address);
 
	        /** Establish a socket connection */
	        Socket connection = new Socket(address, port);
	        logger.debug("SocketClient initialized");
	        /** Instantiate a BufferedOutputStream object */
	        BufferedOutputStream bos = new BufferedOutputStream(connection.
	                getOutputStream());
	            OutputStreamWriter osw = new OutputStreamWriter(bos, encoding);
 
	            if (args[0] !=  null)
	            	fileID=args[0];
 
	            int fileIdentifier  = new Integer(fileID).intValue();
	            String process = "JUNKJUNKJUKNKJUNKJUNK " ;
 
		        logger.debug("file idnetifier:" + args[0]);
 
 
	            /** Write across the socket connection and flush the buffer */
	            osw.write(process);
	            osw.write("fID#" + fileIdentifier + (char) 13);
	            osw.flush();
 
	            /** Instantiate a BufferedInputStream object for reading
	             * incoming socket streams.
	             */
	            BufferedInputStream bis = new BufferedInputStream(connection.
	                getInputStream());
	            InputStreamReader isr = new InputStreamReader(bis);
 
	            /**Read the socket's input and append to a StringBuffer */
	            int c;
	            while ( (c = isr.read()) != 13)
	              instr.append( (char) c);
 
	            /** Close the socket connection. */
	            connection.close();
	            logger.debug(instr);
	           }
	          catch (IOException f) {
	            logger.error("IOException: ", f);
	          }
	          catch (Exception g) {
	            logger.error("Exception: ",g);
	          }
	        }
	 }

package com.test.network;
 
import java.net.*;
import java.io.*;
import java.util.*;
 
import org.apache.log4j.Logger;
 
public class SocketServer implements Runnable {
 
	protected static int port;
	Socket connection;
	static boolean first;
	static String filePath;
 
	private static final Logger logger = Logger.getLogger(SocketServer.class);
	private static ResourceBundle resources = ResourceBundle.getBundle("socket");
 
	private int ID;
	private static int count = 0;
 
	SocketServer(Socket socket, int id) {
		this.connection = socket;
		this.ID = id;
	}
 
	public static void main(String[] args) {
 
		try {
			filePath = resources.getString("filePath");
			port=new Integer(resources.getString("port")).intValue();
			ServerSocket socket = new ServerSocket(port);
			System.out.println("SocketServer Initialized");
 
			while (true) {
				Socket connection = socket.accept();
				Runnable runnable = new SocketServer(connection, ++count);
				logger.debug("count:"+ count);
				Thread thread = new Thread(runnable);
				thread.start();
			}
		} catch (Exception e) {
			System.out.println(e);
		}
	}
 
	public void run() {
		int character;
		String fileOutput = "";
		StringBuffer process;
		String fileName;
		String originalFileName;
 
		try {
			BufferedInputStream is = new BufferedInputStream(
					connection.getInputStream());
			InputStreamReader isr = new InputStreamReader(is);
			process = new StringBuffer();
			while ((character = isr.read()) != 13) {
				process.append((char) character);
			}
			logger.debug("CLINET REQUEST RECEIVED" + process);
			// extract the file Name from the clients request
			String tempFileID = new String(process.toString());
			int index = tempFileID.lastIndexOf("#");
			String temp = tempFileID.substring(index + 1);
			originalFileName = temp;
			fileName = filePath + originalFileName + ".txt";
			logger.debug("fileName:" + fileName);
 
			// 10 seconds delay in response
			Thread.sleep(10000);
 
			try {
				FileReader fr = new FileReader(new File(fileName));
				BufferedReader br = new BufferedReader(fr);
				String s;
				while ((s = br.readLine()) != null) {
					fileOutput = fileOutput + s;
				}
			} catch (Exception e) {
				logger.error("File Reader ERROR:",e);
				throw e;
			}
			// write the filename request in count.txt file
			fileWriter(originalFileName);
			String returnCode = "The requested FileName : "
					+ originalFileName
					+ " And its associated Contents : \t" + fileOutput
					+ (char) 13;
			BufferedOutputStream os = new BufferedOutputStream(
					connection.getOutputStream());
			OutputStreamWriter osw = new OutputStreamWriter(os);
			osw.write(returnCode);
			osw.flush();
		} catch (IOException e) {
			logger.error("IOEXception:",e);
		} catch (Exception e) {
			logger.error("Xception:",e);
		} finally {
			try {
				connection.close();
			} catch (IOException e) {
 
			}
		}
	}
 
	static void fileWriter(String str) {
		try {
			String TimeStamp;
			File fileOutput = new File(filePath + "count.txt");
			FileWriter fstream = new FileWriter(fileOutput, true);
			BufferedWriter out = new BufferedWriter(fstream);
			TimeStamp = new java.util.Date().toString();
			out.newLine();
			out.write(TimeStamp + ":" + str);
			out.close();
		} catch (Exception e) {
			System.out.println(" Error while writing the requested filename"
					+ e);
		}
	}
}

I know this is an old Thread and I apologize, however, the unanswered question interests me greatly.

The TL;DR version of the OPs code is MultiThreading with Sockets. Ie, creating a new Thread for every new connection - I've searched the web for an alternative effective way of handling multiple clients and ultimately ended up here and all I've got is the same old multithreading solution.

Can anyone share insight on what is the new, standard, correct way of handling multiple clients?

Thank you.

Can anyone share insight on what is the new, standard, correct way of handling multiple clients?

It could be that what you're looking for is non-blocking IO with Channels in Java NIO:
JDK 1.4.2 New I/O-related APIs & Developer Guides -- from Sun Microsystems