The Java EE Course - build a Java EE app from scratch

install eclipse IDE for Java EE development by downloading the eclipse IDE from eclipse.org, extracting the zip, configuring the JDK path, and setting a workspace for your projects.

Register your JDK with Eclipse by pointing to the JDK installation in preferences; Windows and Mac steps differ only in location, then finish to complete the setup.

Install GlassFish server and Eclipse tools to deploy Java EE applications, download and extract the GlassFish zip, install Eclipse plugins via the marketplace, and add GlassFish to Eclipse servers.

Configure the GlassFish server in Eclipse by locating the extracted GlassFish folder, then start the server and validate access via localhost ports such as 88 or 4848.

Import an existing project into Eclipse by selecting File, then Import existing projects into a workspace; bind the JDK and set the Java build path to run with GlassFish.

Build a Java EE servlet to add passengers to a flight by creating a dynamic web project in Eclipse, deploying on GlassFish, and handling doGet responses using a print writer.

Create an html form in a jsp to add passengers to the airline data system, with fields for first name, last name, date of birth, and gender.

Add static resources to a JSP-based Java EE app by creating web content resource folders, importing normalize.css and theme.css, and linking them in the JSP to style the form.

Create a passenger Java class with first name, last name, date of birth, and gender, using a gender enumeration, getters, setters, and a toString method.

Extracts form parameters from a post request to create a new passenger object, including first name, last name, date of birth, and gender, via a Java EE controller.

Validate user-submitted form values in a Java EE app by checking first name, last name, date of birth, and gender with regular expressions, and set error attributes.

Improve form validation by preserving entered values on error, using request attributes for first name, last name, and date of birth, and handling post and get flows.

Enterprise JavaBeans act as the business tier, separating business logic from web services, and handle automatic transactions, security, concurrency, and robust database access.

Create a stateless local session bean in a dynamic web project, with flight properties and auto-generated getters, setters, and toString, illustrating local access and bean basics.

Demystify stateless session beans by showing how the EJB container shares a single flight service object across injections, contrasting with stateful behavior. Compare stateless to stateful beans.

Explore how stateless session beans in EJB use a pool of bean objects, so each reference may map to another instance. Learn why setting properties on stateless beans is unreliable.

Learn to look up a flight service EJB via JNDI, cast it to a flight service object, and display its details from the container.

This lecture demonstrates converting a stateless EJB to a stateful bean, removing the remote interface, adjusting injections with names, and deploying to avoid JNDI conflicts.

Learn to look up stateful and stateless EJBs via the Java Naming and Directory Interface (JNDI) in a deployed project, instead of relying on injection.

Learn how to build a singleton session bean with a counter, inject it into servlets, and demonstrate that all injections share a single instance in the EJB container.

Compare singleton and stateful session beans in EJB, examining how each maintains state within a server and why cross-server behavior differs.

Preserve state across sessions by adding a stateful bean to the session context with a session context listener, demonstrating per-session state and a shared stateful bean across servlets.

Explore how the Java Persistence API mediates between enterprise beans and the database, enabling data storage and retrieval with Java objects, no SQL, and multiple providers like EclipseLink and Hibernate.

Choose Derby (Java DB) as the database and start the network server bundled with GlassFish on port 1527. Connect with Eclipse data source explorer to inspect data.

Connect to a Derby database from eclipse using the data source explorer, configure a named airline connection on localhost, and verify the connection with a successful ping.

Create a JPA entity passenger that maps to the passenger table. Define an auto generated id as primary key, a date of birth, and a gender enum stored as string.

Inject an entity manager linked to the airline persistence unit into a stateless session bean to persist passenger information into the database.

Create a passenger object, inject the passenger service EJB, and save the passenger to the database, then verify the auto-generated ID in the data source.

Fix the eclipse validation x by adding the class tag to the persistence.xml and explicitly listing the passenger entity in the persistence unit.

Create and configure flight and airplane JPA entities, including auto-generated primary keys, enumerated origin and destination fields, and a timestamp for flight time, while planning a one-to-one relationship.

Explore how to model a one-to-one relationship between flight and airplane using JPA annotations, including join column and mapped by to create a foreign key in the flight table.

Learn how to persist a flight and its associated airplane in a one-to-one relationship using JPA with an entity manager, a persistence unit named airline, and a flight service.

Create and connect an airplane to a flight to persist a one-to-one relationship using JPA, guiding entity manager persistence and verifying the foreign key.

Persist pilot objects with an ejb session bean and a persistence context via an entity manager, laying groundwork for a one-to-many relationship between pilots and flights in the database.

Define named queries on pilot and flight entities to fetch records by id in a one-to-many flight–pilot setup, and configure JPA projects with distinct persistence units.

Demonstrates a one-to-many relationship between flights and pilots using jpa, showing how to add flights and pilots and assign pilots to flights via foreign keys.

Fetch the list of flights from database using JPA by adding a getFlights method that uses a query to map rows to flight objects and expose list via a controller.

Learn to display pilots for each flight using JSP with JPA, handling one-to-many flight pilots and one-to-one flight airplane relationships, and apply CSS styling for the flights table.

Learn how cascade propagation in JPA enables persisting a flight and its associated airplane automatically, and how cascade remove deletes the linked airplane when removing the flight.

Develop a passenger service to return all passengers by building an on-the-fly JPA query, mirroring the flight service, and laying groundwork for many-to-many relations between flights and passengers.

Create a jsp based passengers list in Java EE by displaying first name, last name, date of birth, and gender, and plan future many-to-many flight relationships.

Learn to build a jsp form to add flights in Java EE app, converting inputs to flight and airplane objects and handling post requests with a redirect to flights page.

Add pilots to flights via a JSP form in a Java EE app. Learn how controllers and services persist pilot data and link pilots to flights.

Demonstrate how to add pilots to flights through a JSP form, including creating a flight and assigning pilots by flight ID, using JPA.

Explore how to implement a many-to-many relationship between flights and passengers using JPA annotations, including the join table and join columns.

Add passengers via a JSP form by updating the passenger controller to read form data and persist a passenger with JPA, including date of birth and gender.

Associate a passenger with a flight in a many-to-many relationship by updating both the flight's passenger list and the passenger's flight tickets.

Demonstrate adding a passenger to a flight and manage the many-to-many relationship between passengers and flights in a Java EE app, with updated lists in the flight and passenger controllers.

Display each passenger’s flight tickets by retrieving a passenger’s associated flights through a many-to-many relationship and a join table, rendering them in the passengers JSP file.

Implement a many-to-many relationship between flights and passengers by adding flight tickets and updating the join table, demonstrated with a Java EE passenger and flight service.

Explore REST for web services with JAX-RS and see how an airline app exposes data to other applications. Identify Jersey and RESTEasy as implementations of the JAX-RS standard.

Create two managed classes to host rest web service methods, inject persistence context and an entity manager, and configure jax-rs paths as gateways to airline services.

Expose rest endpoints that return lists of flights and passengers in JSON and XML using get methods, produces annotations, and Jersey-backed Java EE web services.

Learn to handle not found exceptions in a Java EE web service by throwing not found errors for missing passengers or flights, and avoid internal server errors.

Post a JSON payload representing a passenger to the web service, persist the record, and return a 201 Created with a location header pointing to the new passenger.

Update an existing passenger via a put web service method, fetch by id, handle not-found, apply updates from the request body, and persist changes with a JPA managed entity.

Demonstrates updating a passenger via a web service, including crafting a valid JSON payload, setting the content-type header, and verifying the updated passenger details.

Learn how to delete a flight via a Java EE web service and cascade its related data, including the airplane and pilots, with transactional control.

Install maven by downloading the binary archive, extracting it, configuring MAVEN_HOME and PATH, restarting the command prompt, and verifying with mvn -version.

Learn to create a first console Java application with Maven by selecting an archetype, configuring the group and artifact, managing dependencies, and running a standalone jar.

Learn to create a Maven project, configure dependencies via pom.xml, and use Maven repositories to manage and download libraries for a Java EE app.

Explore how maven organizes builds through phases and lifecycles, revealing how goals, plugins, and phases like compile, test, package, and clean drive project workflows.

Understand maven goals, phases, and lifecycles, building jars or wars in the target folder via the package phase, with eclipse or command-line workflows.

Build a Maven-based web application using servlets and JSP, configure war packaging, src/main/java, webapp resources, and provided scope dependencies for deployment on GlassFish.

Create a multimodule maven project with a parent and two modules, airplane and runway, and configure dependency management so runway can use airplane classes.

Learn practical troubleshooting for a multimodule maven app, including resolving jar not found errors, selecting the correct JDK, and successfully building and running airplane and runway projects.

Migrate an Eclipse airline app into a multi-module Maven project, creating a parent POM, adding models and web app modules, and wiring cross-module dependencies.

Port an airline app from Eclipse to a multimodule Maven project with a main, a parent, and two child modules, then build, package, deploy, and verify the app.

explains Maven life cycle, phases and goals; shows package, jar/war artifacts, plugin roles, and how Maven builds, installs, and shares multi-module projects with standard directory layout.