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.

Define an EJB singleton with the singleton annotation to ensure a single instance across the application, while the EJB API handles concurrency to relieve common access issues.

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.

Explore singleton pattern with an EJB in a Java EE 8 environment, and show container-managed access via annotation while iterating a foods list and invoking a code message.

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.

Deploy and monitor a design patterns driven food service workflow, observe redirects and just-in-time routing for pizza orders, and verify real-time updates through a page refresh.

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

Explore how the EJB singleton pattern provides a single shared instance, with default concurrency management through the singleton annotation, and demonstrate its use with the CGI API.

Discover how to implement a CDI-based singleton in Java EE 8, ensuring a single instance across the application, unlike EJB with built-in concurrency, requiring manual concurrency management.

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.

The lecture demonstrates a deployed application and explains how different EPA constructs realize the same design pattern, comparing their pros and cons to achieve the same result.

Implement a singleton with ejb and let the container manage concurrency, security, and transactions, while cdi provides dependency injection and application context as an alternative approach.

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 the observer pattern as the opposite pattern, where code observes an event and is notified when it occurs, using the API's event mechanism.

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.

Explore the observer with events pattern in Java EE 8 by firing a CDI event on food orders and delivering a payload to an observer, decoupling components across applications.

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.

Explore how to implement the observer pattern in java ee 8 using cdi to log and react to domain events like food orders, with real-time event observation and debugging.

Explore observer patterns with asynchronous events in Java EE 8, showing how to run observers on separate threads to handle long running tasks and improve responsiveness.

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.

Learn how the abstract factory pattern with CDI coordinates two foods, pizza and sushi, via a shared food interface, and how container injection can fail when multiple implementations exist.

Explore the abstract factory pattern with CDI, injecting a food interface and selecting concrete implementations via qualifiers, demonstrating creation versus usage and asynchronous food preparation.

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.

Review how a singleton manages concurrency with copy-on-write thread safety in a food-service module, using asynchronous events and CDI qualifiers to inject sushi service or peas service.

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

Create branches to explore the decorator pattern, including a decorate branch and a decorator branch, then check out and review how the decorator pattern is applied.

Demonstrate the decorator pattern with CDI to add functionality to a sushi food service at run time without altering other services, within Java EE 8.

Demonstrate the decorator pattern with CDI in Java EE 8 to wrap a sushi food service without altering its implementation, using a decorator with delegates and runtime to forward calls.

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.

Demonstrates decorator pattern in Java EE 8 by wrapping a sushi food service, adding 20 grams of salt and pepper through the decorator, with the sushi ready in 20 minutes.

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 how CDI producers use the injection points interface to obtain the class name at injection time and initialize assets and services.

Learn the factory method pattern with CDI producers, showing how producers are injected into a sushi food service and used to supply components in a Java EE 8 context.

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 lecture shows the factoring method implemented with API constructs, using a factory to create calls, clone, and branch paths across examples.

Explore the facade pattern as a black-box interface that hides complexity, with examples of the object pool and proxy patterns in EJBs and container-managed resources.

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 the proxy pattern through a sushi food service proxy, where a container intercepts calls as delegates, providing transactions, security, and logging, with proxies delivering platform services.

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 what design patterns are: general reusable solutions crafted as blueprints and templates to solve software problems within specific contexts, and learn how a single pattern applies across different domains.

Discover how design patterns provide blueprints for reusable solutions across software design, and see how the singleton pattern ensures a single shared instance across the entire application.

Explore the singleton pattern by implementing a single shared class that provides services across the application, such as midnight payment checks for subscribed users.

Explore the observer pattern, where observers register to be notified when specific events occur, enabling asynchronous or secret notification to trigger actions and tasks.

Explore the decorator pattern as a method to add behavior to objects at runtime without altering their syntax, illustrated by runtime composition of a tea type with a specific flavor.

Explore how the factory method pattern differs from the abstract factory pattern and serves as a blueprint for creating objects via class-specific methods, illustrated with an employee example.

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.

Explore the object pool pattern, a design that maintains a pool of reusable objects for efficient resource management and readily available resources in EJB stateless services and application server pools.

Explore the proxy design pattern and how proxies enable runtime functionality and interception in Java objects, showing how injected proxied instances add behavior without direct object creation.

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.

Install NetBeans 8.2, the all-in-one IDE for Java enterprise development, by downloading the bundled package for Windows, Mac OS, or Linux, after ensuring Java is installed, and import sample code.

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

download and set up the GlassFish 5 app server, its web profile reference implementation, extract the zip, accept the license, and add it to the net id.

Download the GlassFish 5 zip, extract it to a location, and configure GlassFish 5 in NetBeans IDE to add it to your development environment.

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

This lecture guides you through creating a new web application project, selecting the GlassFish server, naming it design patterns, and preparing multiple projects to explore core design patterns.

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.