Modern Design Patterns with Java EE 8

Create a singleton branch and implement the singleton pattern in a Java API construct, switching between IDEs to accommodate different users while keeping each pattern in its own branch.

Explore the singleton pattern as a single point of responsibility, its scalability limits due to concurrency, and how to realize it in Java EE 8 using EJB and CDI.

Explore how an EJB singleton uses container-managed concurrency to guarantee a single business method invocation at a time in Java EE 8.

Explore implementing an EJB singleton in Java, including injecting the singleton, testing with a DSF backing, and creating methods to save and retrieve food data.

Discover how a singleton EJB powers a simple JSF form, with input binding, getters and setters, and persistent food orders—illustrating modern design patterns in Java EE 8.

Configure and activate a jsf web app by editing web.xml and index.xhtml, then link to the food service and deploy to a glassfish server for testing.

Investigate how a browser process maintains the same hash throughout, using examples like sushi. Moment of truth demonstrates this with Internet Explorer.

Demonstrates implementing a singleton with the CDI API, using a thread-safe collection and container-managed concurrency to ensure consistent access in a Java EE 8 environment.

Learn how to build robust Java EE applications by compiling and deploying to the GlassFish application server, with a focus on singleton patterns using CDI for reliable state management.

Create and switch between git branches to explore the singleton and observer design patterns in a Java EE 8 project, including common commands and workflow tips.

Explore how to fire a food order event, inject an event, and notify an observer with a payload so the observer can act on the new order.

Register an observer to an event in Java EE 8 and handle the event when it fires, passing a custom data object to the observer.

Activate CDI across the application and apply an event-driven observer pattern; when food is added to an order, a strength payload is fired and observed by a decoupled observer.

Demonstrate the observer pattern with async events by simulating a long-running task that pauses for five seconds, showing how an observer fires and execution resumes.

Learn the observer pattern with asynchronous events in Java EE 8 by wiring a sink and an observer to run on a separate thread and see events in action.

Explore how asynchronous execution preserves responsiveness by using the observer pattern to handle events in Java EE 8, contrasting it with synchronous calls and long running tasks.

Review the observer pattern implementation, including payload creation, event firing, and the distinction between asynchronous and synchronous events, via the API contract.

Learn to implement the abstract tree built from a branch and apply abstract factory concepts in a Git branch setup for design patterns.

Implement the abstract factory pattern with CDI to decouple creation from use in a food preparation scenario, using an interface called food and concrete factories like sushi or milk.

Explore implementing the abstract factory pattern used in the Java API within Java EE 8, wiring front-end actions to a service, database calls, and asynchronous events, via a food-service sample.

Explore implementing the abstract factory, manage code changes with commits, and switch branches to prepare the next design pattern across OS X and Linux.

Demonstrate the decorator pattern with CDI in Java EE 8 by wrapping a sushi service with a decorator to modify behavior and produce console output.

The decorator pattern wraps a class to extend behavior, using the Java API as the decorator for a sushi food service and adding 20 grams of fiber.

Learn how to set up git commits and manage branches, including creating and checking out subbranches and factory pattern branches, to organize design pattern work.

Explore the factory method pattern and how a single method in a domain creates specific object types, contrasting it with abstract factory in Java applications.

Explore how the factory method pattern with CDI producers initializes named singletons via the injection point, reducing boilerplate and clarifying producer configuration.

Explore Java EE 8 design patterns with a moment of truth scenario, injecting dependencies in a food service and a sushi decorator, then ordering sushi and printing the 20-minute readiness.

Explore how a factory produces loggers via the injection point and wire them into the sushi food service and decorator, testing passivation compatibility and a factory method pattern.

The facade pattern uses a boundary to isolate complex subsystems, exposing simple methods for clients while shielding them from underlying services such as stateless EJBs and external API calls.

The object pool design pattern in Java EE 8 creates a pool of stateless EJB instances to serve requests quickly, avoiding costly initialization and improving application performance.

Explore and implement classic design patterns in Java, including singleton, observer, abstract factory, decorator, and factory method, using pure Java API constructs to realize patterns in real applications.

Explore the facade pattern as a barrier between clients and the repository, exposing business methods while hiding implementation details, demonstrated with a Java EE example using a stateless EJB.

Jakarta EE rebrands the platform under the Eclipse Foundation, shifting Java governance to an open, community-driven model with IBM and Red Hat collaborating.

Download the required software from the student resources, choose the correct Windows, Mac OSX, or Linux option, accept the license, and run the appropriate installer.

Explore Java EE 8 production readiness, download the SDK, and learn GlassFish as the reference implementation with insights into new API updates.

Learn Git as a distributed version control system, install the tool across Windows, Mac, and Linux, and follow productive workflows to manage code efficiently.

Upgrade your project to Java EE 8 by configuring artifact and fact IDs and leveraging the Java EE API, then prepare GlassFish and initialize your code management system and .gitignore.

Initialize a Git repository for a Java project, configure .gitignore to exclude environment-specific files, and set up cross-platform workflows (Windows, Mac OSX, Linux) for Eclipse and Java development.

Demonstrates an initial git commit workflow on Windows, including using status, adding changes, ignoring config files with gitignore, and creating a singleton branch to explore the singleton pattern.