Modern WebSockets Application Development with Java EE

Install the java development kit 8 by downloading the full package for Windows, mac os x, or Linux, select 64-bit or 32-bit, and accept the license.

Install the NetBeans IDE (version 8.2) to develop Java EE applications, download the all-in-one package, ensure Java is installed, and import sample code to begin.

install git on Windows, macOS, and Linux using the official git-scm resources, follow platform-specific instructions, and adopt a productive Git workflow for the course projects.

Learn how Apache Maven serves as a dependency management system for Java projects, including how to install Maven, download pre-built binaries for Windows and Linux, and set up your environment.

Java EE is a collection of abstract specifications that standardize solutions to enterprise software challenges, including persistence. These specifications require implementations that turn abstract interfaces and methods into enterprise applications.

Define Java EE as a collection of open standards and standardized abstract specifications for cross-platform software development, implemented by concrete Java runtimes that run applications on a chosen platform.

Java EE is an umbrella of standards for enterprise applications, realized by complete application servers. GlassFish acts as the reference implementation, with Hibernate and web services as concrete APIs.

Explore what Java EE means by examining how a collection of gestures and icons relate to a reference implementation.

Explore how Java EE is defined by the Java Community Process, with open standards, rigorous voting, and expert groups that evolve the platform for long-term industry adoption.

Explore how Java relies on open, standardized abstract specifications shaped by the Java Community Process, and how individuals can join, vote on committees, and give feedback to shape the platform.

Explore what Java EE really is, its standards and reference implementations, and how feedback and progress shape modern web sockets development with GlassFish.

Discover what Java EE really is and how its next major release, expected between May and the end of 2017, affects portable usage.

Sign up as an associate member on the dcp.org site, complete the required forms, and post your feedback in the course forum to kick off the first project.

Explore the platform APIs and lab activities to develop and run applications. Read the documentation to understand how to apply the API insights, with code samples in the next chapters.

Explore the Oracle Java documentation for the web sockets package, review its classes, and understand how the WebSocket interface supports both client and server development.

Explore the programmatic web socket endpoint model, detailing the endpoint class lifecycle, session handling, and the on open, on message, and on close callbacks.

Explore the web socket endpoint on open method, receiving the session object and configuring the message handler to echo client messages back to the client.

Discover how the WebSocket session interface represents a conversation after a handshake, register a message handler for incoming messages, and send replies via a remote object from the session.

Explore the web sockets message handler interface API, implementing a generic message handler for text and binary messages, decoding into GP entities and broadcasting to connected clients.

Explore the remote endpoint basic interface API for web sockets in Java EE, enabling asynchronous, full-duplex messaging, text and binary sends, and session-level control.

Explore the WebSocket encoders API to pack custom objects into text or binary messages, using a JSON text stream and a per-connection encoder interface.

Learn how the Text<T> encoder interface converts custom objects into strings for WebSocket messages, encoding them for delivery by the API across platforms and languages using Java.

explore the WebSocket decoder interface API in Java EE, decoding strings to custom objects via a stream, with session handling, open and on message methods, and type testing.

Define a WebSocket endpoint with the @ServerEndpoint class-level annotation to publish deployable endpoints and configure message sending, encoding, decoding, and custom tag handling.

Learn how the WebSocket @OnMessage API uses method-level annotations to route text, binary, and other message types to dedicated handlers in endpoint classes.

Explore the WebSocket @OnOpen API in java ee, where a new session triggers the open method with specific parameters and a session object to access connected clients at the endpoint.

explore how the WebSocket @OnClose API in Java EE handles connection closures by annotating methods to receive the closing session and manage remaining open sessions.

Use the official API documentation and code samples to explore the WebSocket API in Java EE, and practice by writing and running sample code to see it in action.

Clone or download a sample Java EE WebSocket project and follow along as you build simple apps, connect sockets, and see how the API documentation and prior lessons come together.

Send a message to a websocket server in a simple chat app, where the server rebroadcasts the message to all connected peers.

Configure a WebSocket server endpoint with @ServerEndpoint, manage lifecycle events such as onOpen, onMessage, onClose, and onError, and handle session data for deployment.

WebSockets @OnOpen in Java EE shows how to manage each connection with a unique per-connection point and add sessions to a concurrent pool. Broadcast messages to all connected endpoints.

Explore how the WebSocket ConcurrentLinkedQueue API ensures thread-safe access to the same data by using a first-in-first-out queue to manage connected elements.

Learn how to manage WebSocket lifecycle by using the onOpen and onClose methods to add and remove sessions from the container, keeping connected peers up to date.

Explore the WebSocket CloseReason, an object that provides the reason for a disconnection, and demonstrate methods to access its code and message for handling closures.

Learn how the WebSocket @OnMessage annotation triggers a method for each client message to the server, accessing the message and session, and broadcasting to all connected clients except the sender.

Discover how CDI integration enables seamless object production and injection across websocket endpoints using a factory and injection points in a Java EE environment.

Explore how to use WebSocket endpoints with path parameters in Java EE, injecting path parameter values into message handlers and extracting them for use in the method.

Use WebSocket @PathParam to extract a parameter from the path, convert it to a string, and fetch data from the database to tailor messages.

Explore how a web socket JavaScript client interacts with a Java EE chat endpoint, handling lifecycle events like open, message, and close, and sending messages over a secure ws/wss connection.

Build and test a WebSocket JavaScript client to connect to the Java EE server, send messages, and display server received updates while encouraging hands-on experimentation.

Explore a recap of building web services with the Java EE web sockets API, including CDI integration, annotations, endpoints, and a preview of upcoming topics like magic clients.

Explore web sockets encoders and decoders in java ee, converting a simple pojo to websocket messages and back using a toStream method.

Learn how to implement a web sockets encoder in Java EE by converting a simple POJO to a text message for a session and returning the encoded string to client.

Implement decoding for web sockets by pairing a decode method with the encode method, handling string input, converting to a custom type, and validating input before decoding.

Explore registering WebSocket encoders and decoders in a Java EE application, wiring encoders to endpoints, handling parameters, and posting encoded values for use by the application.

Learn how to use encoders and decoders in Java EE WebSockets to serialize custom POJOs into text for clients and convert incoming messages back into domain objects.

Run through sample code to test WebSockets encoders and decoders, observe message exchanges between clients and server, and review the simple POJO data flow on the endpoint.

Explore WebSockets client development in Java EE by annotating a client endpoint, handling on message events, and comparing client and server endpoints as they exchange messages.

Deploy a WebSocket client using the WebSocketContainer interface and connect to an endpoint, demonstrating client endpoints, server interaction, and message exchange in Java EE WebSockets.

Explore the WebSocketContainer interface, its configuration parameters for session and endpoint buffer control, and how it connects programmatic clients to a server while managing endpoint context.

Explore websockets in a Java EE context by recapping endpoints and client interactions, and compare annotation-based and programmatic approaches to creating and instantiating endpoints.

Extend the programmatic endpoint by overriding onOpen to initialize the session when a client connects. Attach a message handler and implement onMessage to process client messages, using a custom tag.

Explore deploying WebSocket programmatic endpoints by configuring a server application config interface, mounting an endpoint class, and listing annotated endpoint classes to host your WebSocket endpoints.

Explore how the server application uses the ServerApplicationConfig API to specify endpoints, deploy annotated endpoint classes, and return data points within a set for WebSockets in Java EE.

Compare programmatic WebSocket clients with servers in Java EE, focusing on deployment, session handling, on open responses, and implementing a custom message handler for text streams.

Explore programmatic deployment of WebSocket endpoints in Java EE, including using overloaded constructors with multiple parameters, creating connections to endpoints, and verifying runtime behavior.

Run and observe a programmatic WebSocket endpoint in a Java EE app, showcasing bidirectional message exchange between server and clients and its simple configuration and deployment.

Conclude this module by exploring the Java EE WebSockets API, study the Java 7 API docs, and engage actively through the sample project and forums to build asynchronous WebSocket applications.

Explore Java EE 8 features, production readiness, and how to download the SDK with GlassFish as the reference implementation.

Download the GlassFish 5 reference implementation by clicking download, accept the license, and save the zip; extract it and add it to your NetBeans IDE to run the web profile.

Learn how to add GlassFish 5 to the NetBeans IDE, download the GlassFish zip, extract it to a location, and complete the integration to run websocket applications.

Upgrade your project to Java EE 8 by removing redundant dependencies and using default APIs, while configuring GlassFish-based applications for streamlined web sockets development.

Payara Micro, a slim cloud-native Java EE server with MicroProfile support, designed for 70 megabytes of RAM and embedded or standalone deployment.

Package the app with Maven into a war including dependencies, then deploy it with Payara Micro on the command line, or as a self-contained jar, verifying via localhost.

Explore how Jakarta EE emerged from a foundation-led rebranding of Java EE, uniting the open ecosystem with the Eclipse Foundation and major vendors for future-ready, cross-platform Java development.

Jakarta EE moves to the Eclipse Foundation, replacing the JCP with a community-driven working group for vendor-neutral IP governance and open innovation in cloud-native Java.

Subscribe to the Jakarta community mailing list to join lively discussions and help shape the future of Jakarta. Review the web archive to follow past conversations and contribute.