Building a TCP Group Chat App with JavaFX and Maven

SikorSky — Thu, 05 Mar 2026 20:19:25 +0000

Building a Real-Time Group Chat with Java TCP Sockets and JavaFX

We recently implemented a mini project where the objective was to build a real-time group chat application using Java TCP sockets and JavaFX. This article summarizes the architecture, design decisions, and lessons learned during development.

Project Goal

The project required implementing a complete TCP-based chat system with the following capabilities:

A central TCP server
Multiple concurrent clients
Real-time message broadcasting
A command to list active users (allUsers)
Read-only mode when a client connects without a username
JavaFX interfaces for both server and client
Proper separation between networking logic and UI

The main goal was to combine network programming with clean application architecture.

Tech Stack

The system was built using the following technologies:

Language: Java 17
Networking: Java TCP Sockets
UI Framework: JavaFX (GridPane + CSS styling)
Build Tool: Maven
IDE: IntelliJ IDEA

High-Level Architecture

The application follows a Client–Server architecture.

The server accepts multiple socket connections.
Each client connection is handled in a dedicated thread.
The server broadcasts incoming messages to all connected clients.
The client UI displays messages and connection status.

This architecture ensures that the system can support multiple users simultaneously while maintaining real-time communication.

MVC / Separation of Concerns

To keep the application maintainable, we structured both the server and client using a Model–View–Controller approach.

Model

Handles:

TCP sockets
Network input/output
Chat protocol commands

View

Contains only:

JavaFX UI components
Layout and CSS styling

Controller

Responsible for:

Connecting UI events to model logic
Updating the interface when new messages arrive

Separating networking logic from UI logic made the system much easier to debug and extend.

Key Features Implemented

1. Multi-Client Chat

The server supports multiple simultaneous clients.

All messages are broadcast using the following format:

[HH:mm:ss] username: message

This timestamped format improves readability during conversations.

2. Read-Only Mode

If a user connects without providing a username, the client automatically switches to READ-ONLY MODE.

In this mode:

The user can receive messages
The user cannot send messages

This allows users to observe the chat without actively participating.

3. `allUsers` Command

When a client sends the command:

allUsers

The server responds only to that client with the list of active users currently connected to the chat.

4. Graceful Disconnection

Clients can close the session cleanly by typing:

bye

end

This ensures that:

The socket closes correctly
The user is removed from the server's active list
The UI updates accordingly

5. User-Friendly Status Indicators

Both server and client applications include UI indicators such as:

Online / Offline connection status
A live list of connected users
Random color highlighting for users on the server dashboard

These features improve usability and monitoring.

Configuration

Server network parameters are externalized using a configuration file:

server.properties

This allows parameters such as host and port to be modified without recompiling the application.

Build and Run

Both server and client are packaged as separate Maven projects.

Server

cd TCPServer
mvn clean package
java -jar target/tcpserver-1.0.0.jar

Client

cd TCPClient
mvn clean package
java -jar target/tcpclient-1.0.0.jar localhost 3000

Challenges We Faced

Concurrency and Connection Lifecycle

Handling multiple client connections while maintaining stable communication required careful management of thread lifecycle and connection states.

Model–View Decoupling

Directly updating the JavaFX UI from networking threads can lead to unstable behavior.

To solve this, we used callback interfaces and controllers to route updates safely to the UI layer.

Packaging JavaFX Applications

When packaging JavaFX with shaded JARs, module overlap warnings may appear.

These warnings are common in JavaFX builds and typically do not affect runtime behavior.

What We Learned

This project provided valuable experience with:

Real-world socket programming
Managing multiple concurrent clients
Designing applications with MVC architecture
Keeping network logic independent from UI

One key takeaway is that clean architecture significantly simplifies debugging and future improvements.

Future Improvements

Potential improvements for the project include:

Private messaging commands (/msg username message)
Persistent chat history
Migrating to non-blocking NIO sockets
Adding automated integration tests

Final Thoughts

Building a chat system is one of the best ways to learn network programming and concurrency.

This project combined:

Networking
Desktop UI development
Concurrency
Software architecture

For developers learning Java networking, implementing a multi-client chat application is an excellent hands-on exercise that builds strong practical skills.

DEV Community: SikorSky