# **Java Chat Server & Client with File Transfer**
Here's a complete implementation of a **chat server and client** in Java that supports:
- **Real-time messaging**
- **File transfers**
- **Multiple clients**
---
## **1. Chat Server (Handles Multiple Clients & File Transfers)**
```java
import java.io.*;
import java.net.*;
import java.util.*;
public class ChatServer {
private static final int PORT = 12345;
private static Set<ClientHandler> clients = new HashSet<>();
public static void main(String[] args) {
System.out.println("Chat Server is running...");
try (ServerSocket serverSocket = new ServerSocket(PORT)) {
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("New client connected: " + clientSocket);
ClientHandler clientHandler = new ClientHandler(clientSocket);
clients.add(clientHandler);
new Thread(clientHandler).start();
}
} catch (IOException e) {
System.err.println("Server error: " + e.getMessage());
}
}
// Broadcast messages to all clients
public static void broadcast(String message, ClientHandler excludeClient) {
for (ClientHandler client : clients) {
if (client != excludeClient) {
client.sendMessage(message);
}
}
}
// Remove disconnected clients
public static void removeClient(ClientHandler client) {
clients.remove(client);
System.out.println("Client disconnected: " + client);
}
// Thread to handle each client
private static class ClientHandler implements Runnable {
private Socket socket;
private PrintWriter out;
private BufferedReader in;
private String username;
public ClientHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
out = new PrintWriter(socket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// Get username
username = in.readLine();
broadcast(username + " joined the chat!", null);
String clientMessage;
while ((clientMessage = in.readLine()) != null) {
if (clientMessage.startsWith("/file")) {
receiveFile(clientMessage);
} else {
broadcast(username + ": " + clientMessage, this);
}
}
} catch (IOException e) {
System.err.println("Client error: " + e.getMessage());
} finally {
try {
socket.close();
} catch (IOException e) {
System.err.println("Socket close error: " + e.getMessage());
}
removeClient(this);
}
}
// Send a message to this client
public void sendMessage(String message) {
out.println(message);
}
// Receive a file from client
private void receiveFile(String command) throws IOException {
String[] parts = command.split(" ");
String fileName = parts[1];
long fileSize = Long.parseLong(parts[2]);
FileOutputStream fos = new FileOutputStream("server_files/" + fileName);
byte[] buffer = new byte[4096];
int bytesRead;
long remaining = fileSize;
InputStream is = socket.getInputStream();
while (remaining > 0 && (bytesRead = is.read(buffer, 0, (int) Math.min(buffer.length, remaining))) != -1) {
fos.write(buffer, 0, bytesRead);
remaining -= bytesRead;
}
fos.close();
broadcast(username + " sent a file: " + fileName, this);
}
}
}
```
---
## **2. Chat Client (Supports Messaging & File Sending)**
```java
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class ChatClient {
private static final String SERVER_IP = "localhost";
private static final int SERVER_PORT = 12345;
private static Socket socket;
private static PrintWriter out;
private static BufferedReader in;
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
try {
socket = new Socket(SERVER_IP, SERVER_PORT);
out = new PrintWriter(socket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// Get username
System.out.print("Enter your username: ");
String username = scanner.nextLine();
out.println(username);
// Thread to receive messages
new Thread(() -> {
try {
String serverMessage;
while ((serverMessage = in.readLine()) != null) {
System.out.println(serverMessage);
}
} catch (IOException e) {
System.err.println("Connection lost!");
}
}).start();
// Send messages or files
while (true) {
String userInput = scanner.nextLine();
if (userInput.startsWith("/file")) {
sendFile(userInput);
} else if (userInput.equals("/quit")) {
break;
} else {
out.println(userInput);
}
}
} catch (IOException e) {
System.err.println("Client error: " + e.getMessage());
} finally {
try {
socket.close();
scanner.close();
} catch (IOException e) {
System.err.println("Socket close error: " + e.getMessage());
}
}
}
// Send a file to the server
private static void sendFile(String command) throws IOException {
String[] parts = command.split(" ");
String filePath = parts[1];
File file = new File(filePath);
if (!file.exists()) {
System.err.println("File not found!");
return;
}
out.println("/file " + file.getName() + " " + file.length());
FileInputStream fis = new FileInputStream(file);
byte[] buffer = new byte[4096];
int bytesRead;
OutputStream os = socket.getOutputStream();
while ((bytesRead = fis.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
fis.close();
System.out.println("File sent: " + file.getName());
}
}
```
---
## **How to Run This Chat Application**
### **1. Start the Server**
```sh
javac ChatServer.java
java ChatServer
```
- Creates a server on `localhost:12345`.
### **2. Run Multiple Clients**
```sh
javac ChatClient.java
java ChatClient
```
- Enter a **username** when prompted.
- Type messages to chat.
- Send files using `/file <file_path>` (e.g., `/file C:/test.txt`).
- Type `/quit` to exit.
---
## **Key Features**
✅ **Real-time chat** (multiple clients)
✅ **File transfer support** (`/file <path>`)
✅ **Username-based identification**
✅ **Graceful disconnection handling**
Would you like any modifications (e.g., **GUI version**, **encrypted file transfer**, or **Android support**)? 🚀
No comments:
Post a Comment