The goal of this practice program is simply to allow the client to continuously send strings of messages that the user inputs via typing and hitting enter key and prints it to console. The first time around , String messageFromClient = in.readLine(); in Server.java seems to block (Debugger won't let me step out). However after sending it a message like "hello", it continuously runs without blocking anymore.
I've been searching this up for a couple of hours but I guess I'm just not looking at the right places for the solution.
This link Java InputStream blocking read is probably the closest thing I've found that might help me.
Client.java
import java.io.*;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.*;
import java.net.InetAddress;
import java.util.Scanner;
public class Client {
static Socket connectionToServer;
public static void main(String[] args) {
try{
connectionToServer = new Socket("192.168.1.66", 6969);
InetAddress inetAddress = connectionToServer.getInetAddress();
System.out.print(
"Connection successful" +
"Connected to " + inetAddress.getHostAddress() +
"at " + inetAddress.getHostName() + "\n"
);
while(true) {
String input = System.console().readLine();
OutputStreamWriter dOut = new OutputStreamWriter(connectionToServer.getOutputStream());
dOut.write(input, 0, input.length());
//dOut.flush();
dOut.close();
}
} catch (IOException exception){
System.out.print("Failed to create socket");
}
}
}
Server.java
import java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args) {
ServerSocket serverSocket;
try {
serverSocket = new ServerSocket(6969);
System.out.print("Server is up and running \n");
} catch (IOException exception){
serverSocket = null;
System.out.print("Cannot create ServerSocket");
}
while (true){
try {
System.out.print("Waiting from client.");
Socket socket = serverSocket.accept();
Thread newClientSocket = new Thread(new ServerThread(socket));
newClientSocket.start();
System.out.print("New thread created");
} catch (IOException exception){
System.out.print("Failed to create socket");
}
}
}
}
////////////////////////////////////////////////////////////
class ServerThread implements Runnable{
private Socket socket;
//constructor
ServerThread(Socket socket){
System.out.print("I am a new thread");
this.socket = socket;
}
public void run(){
while(true){
try{
System.out.print("Waiting for input.");
InputStreamReader inputStreamReader = new InputStreamReader(socket.getInputStream());
BufferedReader in = new BufferedReader(inputStreamReader);
String messageFromClient = in.readLine();
System.out.print(messageFromClient);
} catch (IOException exception) {
System.out.print(exception);
break;
}
}
}
}
You shouldn't construct a new BufferedReader for each loop iteration, since a BufferedReader will try to fill its buffer completely and possibly read beyond the end of the first line - and that data will be lost, since you're constructing a new BufferedReader after reading only the first line from it.
Move the construction of the BufferedReader out of the loop, that should help you. Also, make sure that you close the socket when you're done with it.
public void run() {
try {
try {
InputStreamReader inputStreamReader = new InputStreamReader(socket.getInputStream());
BufferedReader in = new BufferedReader(inputStreamReader);
while (true) {
System.out.print("Waiting for input.");
String messageFromClient = in.readLine();
System.out.print(messageFromClient);
}
} finally {
socket.close();
}
} catch (IOException exception) {
System.out.print(exception);
// TODO: handle exception
}
}
On the sending side, you shouldn't close the socket's OutputStream for every line, because once you close it, you can't use it anymore. And you should send a newline to the server after the string, as the Console.readLine() method doesn't include it in its return value.
OutputStreamWriter dOut = new OutputStreamWriter(connectionToServer.getOutputStream());
while(true) {
String input = System.console().readLine() + "\n";
dOut.write(input, 0, input.length());
}
dOut.close();
Console.readLine() does not include terminating characters. BufferedReader.readLine() blocks until it gets a terminating newline character
Change this:
String input = System.console().readLine();
To this:
String input = System.console().readLine() + System.lineSeparator();
Related
I have made two programs using Java that can communicate using Socket and They work fine on my own PC. But when I try to do the same thing between two computers, It does not work, as if the computers cannot find each other or something else. (I get the IP Address of the computer that works as the server using ipconfig in CMD)
What ever is wrong here, is not about the code. I even turned off the firewalls on both computers, but I nothing changed. Can anyone help me out?
MyServer.java
import java.io.*;
import java.net.*;
import java.util.*;
public class MyServer {
// Scanner Object
static Scanner scan = new Scanner(System.in);
// Objects
static ServerSocket serverSocket;
static Socket socket;
static DataInputStream dIs;
static DataOutputStream dOut;
public static void main(String[] args) {
try {
// Setting Up Message
System.out.println("Server Waiting For Connections...");
// Setup Server Socket
serverSocket = new ServerSocket(6666);
// Accept Client Connection Request
socket = serverSocket.accept();
// Confirmation Message
System.out.println("Client Connected.");
// Data Input Stream
dIs = new DataInputStream(socket.getInputStream());
// Data Output Stream
dOut = new DataOutputStream(socket.getOutputStream());
String Input = "";
while (!Input.equalsIgnoreCase("close Connection")) {
// Read Client Message
Input = dIs.readUTF();
System.out.print("\nClient: " + Input);
if (!Input.equalsIgnoreCase("close Connection")) {
// Send Server-Side Response
System.out.print("\nResponse: ");
dOut.writeUTF(scan.nextLine());
dOut.flush();
} else {
dOut.writeUTF("Connection Closed.");
dOut.flush();
}
}
closeConnections();
} catch (Exception ex) {
// Error Message
System.out.println("Error: " + ex);
closeConnections();
}
}
public static void closeConnections() {
try {
// Close Connection
dIs.close();
socket.close();
serverSocket.close();
System.out.println("Connection Closed.");
} catch (Exception ex) {
System.out.println("Could Not Close Connections.");
}
}
}
MyClient.java
import java.io.*;
import java.net.*;
import java.util.*;
public class MyClient {
// Scanner Object
static Scanner scan = new Scanner(System.in);
// Objects
static Socket socket;
static DataInputStream dIs;
static DataOutputStream dOut;
public static void main(String[] args) {
try {
// Setup Connection Socket For Client
socket = new Socket("localhost",6666);
// Data Input Stream
dIs = new DataInputStream(socket.getInputStream());
// Data Output Stream
dOut = new DataOutputStream(socket.getOutputStream());
String Input = "";
while (!Input.equalsIgnoreCase("Close Connection")) {
// Send Client-Side Message
System.out.print("\n- Client Message: ");
dOut.writeUTF(scan.nextLine());
dOut.flush();
// Read Server Message
Input = dIs.readUTF();
System.out.print("\nServer Response: " + Input);
}
closeConnections();
} catch (Exception ex) {
// Error Message
System.out.println(ex);
closeConnections();
}
}
public static void closeConnections() {
try {
// Close Connection
dIs.close();
dOut.close();
socket.close();
} catch (Exception ex) {
System.out.println("Could Not Close Connections.");
}
}
}
I have my server code below over here:
public void startServer() {
ServerSocket listener = selectUnusedPortFromRange(1024, 65535);
Thread t = new Thread(new Runnable() {
#Override
public void run() {
try {
String command = null;
while (true) {
Socket socket = listener.accept();
System.out.println("Got a connection from: " + socket.getLocalPort());
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
command = in.readLine();
System.out.println("GOT HERE"); //Not being printed out
if (command != null && !"".equals(command)) {
if ("connection".equals(command)) {
Writer writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
writer.write("success\n");
writer.flush();
}
}
}
}
}
}
t.start();
}
This is my client side:
public void makeConnection() {
try {
Socket socket = new Socket(IP, PORT);
Writer writer = new PrintWriter(socket.getOutputStream(), true);
writer.write("connection\n");
BufferedReader socketRead = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String str;
while ((str = socketRead.readLine()) != null) {
if ("success".equals(str)) {
System.out.println("Successfully saved all hosts to: " + listOfHosts.get(i));
socketRead.close();
socket.close();
iStream.close();
writer.close();
}
}
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
On the client side after I create my socket to the connect to the server I write "connection" into the outputStream of the socket and wait for an acknowledgement back from the server saying success. For some reason the connection is not being made to the server. In the server System.out.println("Got a connection from: " + socket.getLocalPort()); this line is not being printed out.
Is there something wrong that I am doing. I can't spot it. And I am not getting an exception thrown when I try to connect to my server.
1) Make sure you use the same port for both the Client and Server. They must communicate over the same port. It seems you may be using different ports currently.
2) Make sure you actually start your server thread. As-is in your code above, you make a new Thread, but never start it. t.start() must be called somewhere.
3) If this is on your local machine, you may be better off using localhost instead of the actual IP address. Firewalls might treat your external IP differently.
4) Terminate your messages with a newline character, such as \n, so that your BufferedReader can use it's readLine() method. For good measure, also follow-up by flushing the writer's buffer, just in case the newline character didn't trigger that. writer.flush();
And lastly, make sure you terminate the JVM before trying to run your code again. Your code has not shutdown mechanism to un-bind the server from the port... so you may get an exception thrown telling you the port and/or address are already in use. If that happens, either change ports, or kill the java process running in the background.
Here is your code, slightly modified to run on my system. It's working as you might expect it to. I tried to change as little as possible just to get it working on my system. One note is, I hard-coded the port number into the server and client - that's not required, it was just convenient for me to test with:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;
public class Test {
public static void main(String[] args) throws IOException {
Test test = new Test();
test.startServer();
test.makeConnection();
}
public void startServer() throws IOException {
final ServerSocket listener = new ServerSocket(60001);
Thread t = new Thread(new Runnable() {
#Override
public void run() {
try {
String command = null;
while (true) {
Socket socket = listener.accept();
System.out.println("Got a connection from: " + socket.getLocalPort());
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
command = in.readLine();
System.out.println("GOT HERE");
if (command != null && !"".equals(command)) {
if ("connection".equals(command)) {
Writer writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
writer.write("success\n");
writer.flush();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
t.start();
}
public void makeConnection() {
System.out.println("Making Connection");;
try {
Socket socket = new Socket("localhost", 60001);
Writer writer = new PrintWriter(socket.getOutputStream(), true);
writer.write("connection\n");
writer.flush();
BufferedReader socketRead = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String str;
while ((str = socketRead.readLine()) != null) {
if ("success".equals(str)) {
System.out.println("Successfully saved all hosts to: "); //+ listOfHosts.get(i));
socketRead.close();
socket.close();
//iStream.close();
writer.close();
}
}
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
I was facing the exact same issue. I overcame it by using an ACK mechanism (Wasn't my idea, it was suggested to me). The idea is that client would make a request to server and keep the socket connection alive (and the ouput stream open) till server responds back an agreed ACK message over the same channel. Once the client receives the ACK message, only then it would close the connection.
Below is the code for Server :-
final ServerSocket listener = new ServerSocket(11111);
Thread t = new Thread(new Runnable() {
#Override
public void run() {
try {
String command = null;
while (true) {
System.out.println("About to accept");
Socket socket = listener.accept();
System.out.println("Got a connection from: " + socket.getLocalPort());
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
StringBuilder str = new StringBuilder(inputStream.readUTF());
//command = in.readLine();
System.out.println("GOT HERE. Msg received : "+str);
if (str != null && !"".equals(str.toString())) {
command = str.toString();
if ("connection".equals(command)) {
System.out.println("Got connection message");
DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
outputStream.writeUTF("connection");
outputStream.close();
}
}
inputStream.close();
System.out.println("Done");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
});
t.start();
}
Client :-
public void makeConnection() {
try {
System.out.println("In makeConnection");
Socket socket = new Socket("127.0.0.1", 11111);
DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
outputStream.writeUTF("connection");
InputStream inputStream = socket.getInputStream();
DataInputStream dataInputStream = new DataInputStream(inputStream);
StringBuilder str;
do {
str = new StringBuilder(dataInputStream.readUTF());
} while (!str.toString().equals("connection"));
System.out.println("Successfully saved all hosts to: ");
outputStream.close();
dataInputStream.close();
socket.close();
outputStream.close();
}catch (Exception e) {
System.out.println(e.getMessage());
}
}
A call to start the proceedings :-
public void start() throws IOException, InterruptedException {
System.out.println("Starting server");
startServer();
Thread.sleep(1000);
System.out.println("Starting connection");
makeConnection();
}
I am trying to implement a client server socket connection where i am passing commands like ls/pwd over the GUI and I use an url(localhost) to establish the server connection at the port. Although i am able to establish a connection with client ,the code does not proceed beyond the Client Connection accepted state. I.e. it does not read the input at the server end which was sent by the client over the socket. Below are my three classes, Mainserver, ClientHandler(this handles the thread connections for the server)and the Client.
This is the Client Action button performed code:
private void jButton1ActionPerformed(java.awt.event.ActionEventevt) {
command = jTextField1.getText();
String url = jTextField3.getText();
try {
System.out.println("Before socket connection");
Socket socket = new Socket(url, 9002);
System.out.println("After socket connection");
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println("After Buffered readers");
System.out.println("After getting streams");
if (socket != null) {
try {
int x = Integer.parseInt(command);
flag = 1;
} catch (Exception e) {
flag = 0;
}
if (flag == 0) {
String[] cmd = {"/bin/sh", "-c", command};
System.out.println("the value of command in GUI class is " + Arrays.toString(cmd));
try {
String commd = Arrays.toString(cmd);
System.out.println(commd);
out.write(commd);
input = in.readLine();
}
catch (IOException ex1)
{
Logger.getLogger(TestGUI.class.getName()).log(Level.SEVERE, null, ex1);
}
jTextField2.setText(input.toString());
}
}
}//try end of the first one
catch (IOException ex) {
Logger.getLogger(TestGUI.class.getName()).log(Level.SEVERE, null, ex);
}
The server class:
public class ServerMain {
public static void main(String[] args) throws IOException, InterruptedException {
int number, temp;
try {
ServerSocket serverSocket = new ServerSocket(9002);
System.out.println("server has been started in the server");
System.out.println("Server is waiting connection at" + InetAddress.getLocalHost().getCanonicalHostName() + "port" + serverSocket.getLocalPort());
while (true) {
Socket socket = serverSocket.accept();
System.out.println("Client Connection Accepted");
//pass on handling on this client to a thread
(new ClientHandler(socket)).start();
}
} catch (Exception e) {
System.err.println("Server already in use");
System.exit(-1);
}
}
}
The client Handler for the Server:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* #author ameerah
*/
public class ClientHandler extends Thread {
private static int BUFSIZE = 1024;
private StringBuffer result;
ServerSocket serverSocket;
String serverText;
StringBuffer output = new StringBuffer();
private Object serversocket;
public Socket getSock() {
return sock;
}
public void setSock(Socket sock) {
this.sock = sock;
}
Socket sock;
public ClientHandler(Socket sock) {
this.sock = sock;
}
#Override
public void run() {
PrintWriter outWriter = null;
try {
BufferedReader myInput = new BufferedReader(new InputStreamReader(sock.getInputStream()));
outWriter = new PrintWriter(sock.getOutputStream());
System.out.println(
"before accepting the command in server");
String inputLine;
while ((inputLine = myInput.readLine()) != null) //String command = myInput.readLine();
{
System.out.println(inputLine);
String result = "";
try {
result = executeCommand(inputLine);
} catch (IOException ex) {
Logger.getLogger(ClientHandler.class.getName()).log(Level.SEVERE, null, ex);
} catch (InterruptedException ex) {
Logger.getLogger(ClientHandler.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println(result);
outWriter.write(result);
}
} catch (IOException ex) {
Logger.getLogger(ClientHandler.class.getName()).log(Level.SEVERE, null, ex);
} finally {
outWriter.close();
}
}
public String executeCommand(String cmd)
throws IOException, InterruptedException {
try {
Process p = Runtime.getRuntime().exec(cmd);
p.waitFor();
BufferedReader reader
= new BufferedReader(new InputStreamReader(p.getInputStream()));
System.out.println("Inside the execute method");
String line = "";
while ((line = reader.readLine()) != null) {
output.append(line + "\n");
}
} catch (Exception e) {
e.printStackTrace();
}
return output.toString();
}
}
I have been at it for some time, and tried using different streams such as ObjectInputStream, ObjectOutputStream, but the code hangs each time. I cannot see at this point where Im going wrong :( I've searched in several forums but I do not still get an idea where Im going wrong here.Would appreciate any help.!
Best Regards
It was the readLine() which was expecting '\n' at the end. Therefore once i appended '\n' at the end and added out.flush() it was able to read and not keep hanging waiting for more inputs, and now the application is working.
Thank you very much for your helpful suggestions. The out.flush() advice proved to be very helpful.
Few tips to isolate the problem.
Check the value of command and catch Exception stack trace.
After out.write(commd); : add one more line out.flush(); After flush, server will get the data from client. Same is the case with outWriter. flush() should be called on outWriter after writing the data.
You are looking for an end of line to end your input loop but you are using write.
Change your send data statements to use println.
Client:
out.println(commd);
Server:
outWriter.println(result);
I want my clients to continuously read/write to a log file at a remote server.
The way I am doing it is by passing the output of tail -f /root/log.txt from my remote server to my clients.
There are 2 problems I faced
My Server is executing the command but my client is not receiving the output.
Only one client can connect to the server even though I used threading
Client.java
import java.io.*;
import java.net.*;
public class Client
{
Socket sock;
String server = "XXX.XXX.XX.XX";
int port = 5550;
String filename = "/root/log.txt";
String command = "tail -f "+filename+"\n";
public static void main(String[] args)
{
new Client();
}
public Client()
{
openSocket();
try
{
// write to socket
BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
wr.write(command);
wr.flush();
// read from socket
BufferedReader rd = new BufferedReader(new InputStreamReader(sock.getInputStream()));
String str;
while ((str = rd.readLine()) != null)
{
System.out.println(str);
}
rd.close();
}
catch (IOException e)
{
System.err.println(e);
}
}
private void openSocket()
{
// open a socket and connect with a timeout limit
try
{
InetAddress addr = InetAddress.getByName(server);
SocketAddress sockaddr = new InetSocketAddress(addr, port);
sock = new Socket();
// this method will block for the defined number of milliseconds
int timeout = 2000;
sock.connect(sockaddr, timeout);
}
catch (UnknownHostException e)
{
e.printStackTrace();
}
catch (SocketTimeoutException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
Server.java
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
private int portNo = 0;
private Socket socket = null;
public Server(int portNo) {
this.portNo = portNo;
Thread t = new Thread(new acceptClient());
t.start();
}
class acceptClient implements Runnable {
public void run() {
//while(true) {
try {
ServerSocket sSocket = new ServerSocket(portNo);
socket = sSocket.accept();
System.out.println("A client has connected!");
BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(rd.readLine());
rd.close();
Process p = null;
p = Runtime.getRuntime().exec("tail -f /root/log.txt");
BufferedReader rd2 = new BufferedReader(new InputStreamReader(p.getInputStream()));
String s = null;
while ((s = rd2.readLine()) != null) {
System.out.println(s);
wr.write(s);
}
rd2.close();
wr.close();
/*try {
p.waitFor();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
// /sSocket.close();
} catch(IOException exception) {
System.out.println("Error: " + exception);
}
//}
}
}
public static void main(String[] args) {
int portNo = 5550;
new Server(portNo);
}
}
My Server is executing the command but my client is not receiving the output.
That's because, your command tail -f is a never ending command (if I am not wrong).
Hence rd2.readLine() will never return null in Server.java.
Which means your while loop will never exit.
Which means, wr.write(s) will keep writing to the stream, but doesn't get a
chance to flush() or close() it.
Hence, the output doesn't reach
the client.
To Fix: Just add flush() below your write().
wr.write(s);
wr.flush();
// While loop close.
Only one client can connect to the server even though I used threading
That's because, you are accepting connection only once in Server.java.
Just creating a new thread will not accept many connections. You need to accept it many times in a loop.
I would suggest you to sSocket.accept() and then create a separate thread for each accepted connection in a loop.
EDIT: Ik it is long but does anyone know how to program sockets??
My problem is confusing me a bit. I have a server running on one computer and on another, I have a client connected to it. When I type a message from the client into the console and send it, the server does not seem to receive it. Anybody know why because I have been testing with printing to the console for the last 3 hours and cannot figure this out. I am relatively new to sockets so don't be too harsh if I am just being an idiot.
Heres my code for the client side:
import java.net.*;
import java.util.Scanner;
import java.io.*;
public class SocketClient {
public static void main(String [] args) {
String host = "************";
int port = 25565;
StringBuffer instr = new StringBuffer();
String TimeStamp;
System.out.println("SocketClient initialized");
try {
InetAddress address = InetAddress.getByName(host);
Socket connection = new Socket(address, port);
BufferedOutputStream bos = new BufferedOutputStream(connection.getOutputStream());
OutputStreamWriter osw = new OutputStreamWriter(bos, "US-ASCII");
Scanner scan = new Scanner(System.in);
String message = scan.nextLine();
TimeStamp = new java.util.Date().toString();
String process = "Server called on " + host + ":" + port + " at " + TimeStamp + ": " + message + (char) 13;
osw.write(process);
osw.flush();
BufferedInputStream bis = new BufferedInputStream(connection.getInputStream());
InputStreamReader isr = new InputStreamReader(bis, "US-ASCII");
int c;
while ( (c = isr.read()) != 13)
instr.append( (char) c);
connection.close();
System.out.println(instr);
} catch (UnknownHostException e) {
System.err.println("UnknownHostException: " + e);
} catch (IOException e) {
System.err.println("IOExcepion: " + e);
}
}
}
Here is the code to connect the client to the server:
import java.io.IOException;
import java.net.*;
public class MultipleSocketServer {
public static Socket connection;
public static String name = "Tyler's Server";
public static int limit = 2;
public static Thread[] clients = new Thread[limit];
public static int current = 0;
public static int port = 25565;
public static String[] connected = {"", ""};
public static ServerSocket socket;
public static void main(String[] args) {
System.out.println("Server starting...");
try {
ServerSocket socket = new ServerSocket(port);
while(true) {
Socket connection = socket.accept();
String ip = connection.getRemoteSocketAddress().toString().substring(1, 13);
loop:
for(int i = 0; i < connected.length; i++) {
if(connected[0].equals(ip) || connected[1].equals(ip)) {
break loop;
}else if(!connected[i].equals(ip)) {
connected[i] = ip;
System.out.println(ip);
MultiServer_Client client = new MultiServer_Client(connection, i);
Thread run = new Thread(client);
run.start();
break loop;
}
}
}
} catch (IOException e1) {
System.out.println("Could not bind server on: " + port);
System.exit(-1);
}
}
}
And here is my code to handle each client as connected:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class MultiServer_Client implements Runnable {
public String time;
public Socket client;
public StringBuffer process = new StringBuffer();
public BufferedInputStream inputStream;
public InputStreamReader reader;
public BufferedOutputStream outputStream;
public OutputStreamWriter writer;
public boolean connected = true;
public int ID;
public MultiServer_Client(Socket connection, int i) {
client = connection;
ID = i;
try {
inputStream = new BufferedInputStream(client.getInputStream());
reader = new InputStreamReader(inputStream);
outputStream = new BufferedOutputStream(client.getOutputStream());
writer = new OutputStreamWriter(outputStream, "US-ASCII");
} catch (IOException e) {
System.out.println("IOException: " + e);
}
System.out.println("Client connected...");
write("Connected to " + MultipleSocketServer.name);
}
public void run() {
while(connected) {
write("hi");
}
System.out.println("Disconnecting client...");
}
public void write(String authen) {
try {
time = new java.util.Date().toString();
String message = time + ": " + authen + (char) 13;
writer.write(message);
writer.flush();
} catch (IOException e) {
connected = false;
MultipleSocketServer.connected[ID] = "";
}
}
public void read() {
//read from client
int character;
process = new StringBuffer();
try {
while ((character = reader.read()) != 13) {
process.append((char) character);
}
System.out.println(process);
process.delete(0, process.length());
} catch (IOException e) {
connected = false;
MultipleSocketServer.connected[ID] = "";
}
}
}
Srry if I cannot help very much. As I said, I am new to sockets and no one else seems to have any problems with this... Thanks :)
The problem with your code is not the "sockets" its your communication protocol. You are effectively closing the socket before the server has a chance to write out "hi".
To debug this, you want to reduce the complexity of your program. There are a number of things that don't make any sense or matter in your program.
So, a little background on Sockets. There are two types of sockets. A "ServerSocket" and a "Socket" The ServerSocket is sort of like a secretary. Its only job is to listen for calls and then pass them on. This is what the "accept" does. Before any client connects, the accept() will block until it receives a connection. Once the client connects, the accept returns a Socket representing the connection.
The regular Socket is where all the work occurs. You can think of it as a telephone connection. You can talk to someone remotely with the OutputStream, and listen using the InputStream. The challenge is that you need to create some sort of communication (called a protocol) for your two sockets to communicate.
You need to figure out how you want to delimit your commands. You could pass a fixed length number and then the data if you want a "length" delimited protocol or you could use a special character for the end of the message (what you currently have). For the quick and dirty, I often use the latter with a newline character. The easiest is to just use a PrintWriter for writing and a Scanner for reading.
The next step is to figure out the communication pattern for the client and the server. Think if it as passing a ball back and forth. If the client says something, the other side should be listening (and vice versa).
Once the protocol and logic is figured out, you can then move the logic for "handling" the server side into separate threads (called a worker pattern) so that the server can handle more than one client at a time. If you want to go even further, you can implement a reactor with a thread pool so that the server doesn't run out of threads, but that is probably for another day/question.
I would recommend following the Java tutorial on Sockets: http://docs.oracle.com/javase/tutorial/networking/sockets/index.html