I'm trying to make a client-server socket connection that will send message objects (type,sender,reciever,time,message).
When my client tries connecting the server recognises the connection but the client keeps waiting on objectInputStream = new ObjectInputStream(socket.getInputStream());.
I've seen answers on here suggesting that you should make the outputsream first and then the input but it didn't change anything. I am not sure what I am missing.
Client:
class Message {
//...
}
public class ChatClient extends Thread
{
protected int serverPort = 1234;
public static void main(String[] args) throws Exception {
new ChatClient();
}
public ChatClient() throws Exception {
Socket socket = null;
ObjectOutputStream objectOutputStream = null;
ObjectInputStream objectInputStream = null;
// connect to the chat server
try {
System.out.println("[system] connecting to chat server ...");
socket = new Socket("localhost", serverPort); // create socket connection
objectOutputStream = new ObjectOutputStream(socket.getOutputStream()); // create output stream for sending messages
// works until here
objectInputStream = new ObjectInputStream(socket.getInputStream()); // create input stream for listening for incoming messages
// GETS STUCK HERE
System.out.println("[system] connected");
ChatClientMessageReceiver message_receiver = new ChatClientMessageReceiver(objectInputStream); // create a separate thread for listening to messages from the chat server
message_receiver.start(); // run the new thread
} catch (Exception e) {
e.printStackTrace(System.err);
System.exit(1);
}
// reading stuff from terminal and sending messages to the chat server
this.sendMessage(tmp, objectOutputStream); // send the message to the chat server
// cleanup
objectOutputStream.close();
objectInputStream.close();
std_in.close();
socket.close();
}
private void sendMessage(Message message, ObjectOutputStream objectOutputStream) {
try {
objectOutputStream.writeObject(message); // send the message to the chat server
objectOutputStream.flush(); // ensure the message has been sent
} catch (IOException e) {
System.err.println("[system] could not send message");
e.printStackTrace(System.err);
}
}
}
// wait for messages from the chat server and print the out
class ChatClientMessageReceiver extends Thread {
private ObjectInputStream objectInputStream;
public ChatClientMessageReceiver(ObjectInputStream objectInputStream) {
this.objectInputStream = objectInputStream;
}
public void run() {
try {
Message message;
message = (Message)objectInputStream.readObject();
System.out.println("["+message.sender+"] " + message.message);
} catch (Exception e) {
System.err.println("[system] could not read message");
e.printStackTrace(System.err);
System.exit(1);
}
}
}
Server:
class Message {
//...
}
public class ChatServer {
protected int serverPort = 1234;
protected List<Socket> clients = new ArrayList<Socket>(); // list of clients
public static void main(String[] args) throws Exception {
new ChatServer();
}
public ChatServer() {
ServerSocket serverSocket = null;
// create socket
try {
serverSocket = new ServerSocket(this.serverPort); // create the ServerSocket
} catch (Exception e) {
System.err.println("[system] could not create socket on port " + this.serverPort);
e.printStackTrace(System.err);
System.exit(1);
}
System.out.println("[system] listening ...");
try {
while (true) {
Socket newClientSocket = serverSocket.accept(); // wait for a new client connection
synchronized(this) {
clients.add(newClientSocket); // add client to the list of clients
}
ChatServerConnector conn = new ChatServerConnector(this, newClientSocket); // create a new thread for communication with the new client
conn.start(); // run the new thread
}
} catch (Exception e) {
System.err.println("[error] Accept failed.");
e.printStackTrace(System.err);
System.exit(1);
}
// close socket
System.out.println("[system] closing server socket ...");
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace(System.err);
System.exit(1);
}
}
// send a message to all clients connected to the server
public void sendToAllClients(Message message) throws Exception {
//...
}
//...
public void removeClient(Socket socket) {
synchronized(this) {
names.remove(socket.getPort());
}
}
}
class ChatServerConnector extends Thread {
private ChatServer server;
private Socket socket;
private ObjectInputStream objectInputStream;
private Message message;
public ChatServerConnector(ChatServer server, Socket socket) {
this.server = server;
this.socket = socket;
}
public void run() {
try {
objectInputStream = new ObjectInputStream(this.socket.getInputStream()); // create input stream for listening for incoming messages
System.out.println("[system] connected with " + this.socket.getInetAddress().getHostName() + ":" + this.socket.getPort());
} catch (IOException e) {
System.err.println("[system] could not open input stream!");
//...
return;
}
while (true) { // infinite loop in which this thread waits for incoming messages and processes them
message = new Message();
try {
message = (Message)objectInputStream.readObject();
} catch (Exception e) {
//...
}
switch(message.type) {
//...
case "public":
try {
this.server.sendToAllClients(message); // send message to all clients
} catch (Exception e) {
//..
}
return;
default:
//...
}
}
}
}
