Tcp socket programming in java example

Tcp socket programming in java example

Here is an example of TCP socket programming in Java:

Server Side

The server side code is responsible for accepting incoming connections from clients and processing their requests. In this example, we will create a simple echo server that echoes back the messages sent by clients.

import java.io.*;
import java.net.*;
public class TcpServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8000);
System.out.println("TcpEchoServer is running...");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("Client connected");
// Create a separate thread to handle the client
Thread t = new Thread(new EchoThread(socket));
t.start();
}
}
private static class EchoThread extends Thread {
private Socket socket;
public EchoThread(Socket s) {
this.socket = s;
}
public void run() {
try (BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream())) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = bis.read(buffer)) != -1) {
bos.write(buffer, 0, bytesRead);
}
} catch (IOException e) {
System.out.println("Error handling client");
} finally {
try {
socket.close();
} catch (IOException e) {
System.out.println("Error closing socket");
}
}
}
}
}

Client Side

The client side code is responsible for establishing a connection with the server and sending requests to it. In this example, we will create a simple client that sends a message to the echo server and prints out the response.

import java.io.*;
import java.net.*;
public class TcpClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 8000);
System.out.println("Connected to server");
// Create a PrintWriter to send data to the server
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
// Send a message to the server and print out the response
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while ((line = in.readLine()) != null) {
System.out.println("Server: " + line);
}
out.close();
socket.close();
}
}

How it Works

The server side code creates a ServerSocket object and listens for incoming connections on port 8000. When a client connects, the server creates a separate thread to handle that client using an EchoThread. The EchoThread reads from the client's input stream, writes to the client's output stream, and then closes the socket when it is done.

The client side code establishes a connection with the echo server, sends a message to the server, and then prints out the response. It uses a PrintWriter object to send data to the server and a BufferedReader object to read the response from the server.

Advantages

This example demonstrates several key concepts in TCP socket programming:

Conclusion

This example demonstrates a simple TCP echo server using Java. It shows how to establish connections with clients, read from input streams, and write to output streams. This fundamental understanding of TCP socket programming is essential for building robust and scalable network applications.

What is TCP socket in Java?

I'd be happy to explain what a TCP socket is in Java.

In computer networks, sockets are endpoints for communication between two devices (computer, phone, etc.) in a network. They provide a way to establish a connection-oriented or connectionless service between the two devices. A TCP socket, also known as a Transmission Control Protocol (TCP) socket, is a specific type of socket that uses the TCP protocol.

In Java, a TCP socket is implemented using the java.net.Socket class. This class provides a way to establish a connection with another device on the network and send or receive data over that connection. The Socket class represents a single, bidirectional stream of bytes between two devices - either one-to-one (e.g., client-server) or one-to-many (e.g., server-multiple clients).

Here's how it works:

In Java, a TCP socket is commonly used in network programming for:

Here's an example code snippet to demonstrate the creation of a TCP socket and its usage:

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpSocketExample {
public static void main(String[] args) {
// Create a server socket
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Server listening on port 8080...");
// Accept incoming connections
Socket clientSocket = serverSocket.accept();
System.out.println("Client connected");
// Receive data from the client
byte[] buffer = new byte[1024];
int bytesRead = clientSocket.getInputStream().read(buffer);
String message = new String(buffer, 0, bytesRead);
System.out.println("Received message: " + message);
// Send a response back to the client
String response = "Hello, Client!";
clientSocket.getOutputStream().write(response.getBytes());
}
}

In this example, we create a server socket that listens on port 8080 and accepts incoming connections from clients. Once connected, we receive data from the client, process it, and send a response back to the client.

Overall, TCP sockets provide a fundamental mechanism for establishing reliable, connection-oriented communication between devices in a network, which is crucial in many areas of computer networking and programming.