Developing Applications for the Java EE 7 Platform Ed 1
Application requirements need to become clear, maintainable code. Use Java to structure your development approach and connect technical decisions to expected behaviour. Strengthen your ability to design, test and evolve applications independently.
- Duration
- 5 days 35 hours
- Code
- D98817GC10 Code
Presentation
Developing Applications for the Java EE 7 Platform teaches you to create and deploy enterprise applications compliant with Java Platform, Enterprise Edition 7. Technologies covered include annotations, Enterprise JavaBeans (EJB), Java Persistence API (JPA), Java Transaction API (JTA), Servlets, JavaServer Pages (JSP), JavaServer Faces (JSF), Contexts and Dependency Injection (CDI), JAX-RS RESTful and SOAP web services, the Java API for WebSocket, Java Message Service (JMS), Bean Validation, the Batch API, timer services and Java EE Concurrency.
The course helps Java developers who want to harness Java EE 7's full capabilities to:
- use the Java Persistence and Java Transaction APIs;
- create a flexible component model using EJB and CDI, and provide timer, concurrency and batch processing services;
- create SOAP and REST web services;
- develop web-based interfaces using Servlets, JavaServer Pages and JavaServer Faces;
- assemble and deploy Java applications to a JEE application server.
Objectives
Gain hands-on experience building Java EE 7 applications. You will create web-based user interfaces with HTML5 and JavaScript alongside JSP, JSF and servlets. These interfaces use AJAX to communicate with the RESTful web services you create. Business logic is handled through CDI and EJB components. You will also create and use JMS resources, batch processing components and timer components, and learn to persist application data using JPA and JTA.
You will gain the knowledge needed to:
- deploy Java EE applications;
- implement business logic using POJOs, EJBs, SOAP web services and JMS;
- manage persistence using JPA entities;
- create Java web applications using servlets, JSP, JSF, REST services and WebSockets;
- secure Java EE applications.
Practical exercises
During the practical sessions, you will develop a product management application. It starts as a simple client-server application and evolves into a Java enterprise application containing:
- Java Persistence API components to manage product database objects;
- Enterprise JavaBeans components to handle product management business logic, and Java Message Service API components to produce and consume messages;
- a SOAP web service to generate product quotations;
- a web user interface for searching, viewing and updating products, built with Servlets, JavaServer Pages and JavaServer Faces;
- a REST service to check product discounts;
- a WebSockets application to enable conversations between users;
- security implemented through both programmatic and declarative approaches.
Program
Introduction to Java EE
- Standards, containers, APIs and services.
- Application component capabilities associated with tiers and containers.
- Connecting application components with CDI annotations and JNDI.
- Web container, business logic implementation and web service technologies.
- Integration and deployment.
- Enterprise JavaBeans, managed beans and CDI beans.
- Understanding lifecycle and memory scope.
- Connecting components through annotations, injection and JNDI.
Managing persistence using JPA entities
- Creating JPA entities with object-relational mappings (ORM).
- Using the entity manager to perform database operations with JPA entities.
- Managing entity data through conversion, validation and key generation.
- Describing persistence management and locking mechanisms.
- Creating and executing JPQL statements.
Implementing business logic with EJBs
- Creating session EJB components.
- Creating EJB business methods.
- Managing the EJB lifecycle through container callbacks.
- Using asynchronous EJB operations.
- Controlling transactions and creating EJB timers.
- Creating and applying interceptors.
Using the Java Message Service API
- Describing JMS messaging models.
- Implementing Java SE and Java EE message producers and consumers.
- Using durable consumer and shared topic subscriptions.
- Creating message-driven beans and using transactions with JMS.
Implementing SOAP services with JAX-WS
- Describing SOAP web service structure.
- Creating SOAP web services using JAX-WS.
- Creating SOAP web service clients.
Creating Java web applications with servlets
- Describing HTTP fundamentals.
- Creating Java servlet classes and mapping them to URLs.
- Managing HTTP headers, parameters and cookies.
- Using servlets to process different content types.
- Managing the servlet lifecycle through container callback methods.
- Using CDI managed beans.
- Using interceptors and filters.
- Implementing asynchronous servlets and using the NIO API.
Creating Java web applications with JSP
- Describing the JSP lifecycle.
- Describing JSP syntax.
- Using Expression Language (EL).
- Using CDI beans.
- Using tag libraries.
- Handling errors.
Implementing REST services with JAX-RS
- Understanding REST service conventions.
- Creating REST services using JAX-RS.
- Consuming REST services on the client side.
Creating Java applications with WebSockets
- Understanding the WebSocket communication style.
- Creating WebSocket endpoint handlers using JSR 356.
- Managing WebSocket endpoint lifecycle.
- Producing and consuming WebSocket messages.
- Handling errors.
- Encoding and decoding JSON messages.
- Providing a WebSocket client endpoint handler using JavaScript.
Developing web applications with JavaServer Faces
- Describing the JSF lifecycle and architecture and understanding JSF syntax.
- Using JSF tag libraries.
- Applying validators and converters to UI components.
- Using UI templates.
- Defining navigation and managing localisation.
- Producing messages.
- Using Expression Language (EL) and CDI beans.
- Adding AJAX support.
Securing Java EE applications
- Understanding Java EE security architecture.
- Configuring authentication using login modules.
- Defining application roles and security constraints.
- Using programmatic security.
- Web service security standards.
Appendices and additional content
- Java logging.
- CDI beans.
- Bean Validation and JPA.
- Batch and Concurrency APIs.
- JAXB.
- Pre-CDI servlet examples.
Audience
This course is for application developers, J2EE developers and systems integrators.
Prerequisites
Required prerequisites
- Experience with XML.
- Experience with core database concepts, basic SQL knowledge and experience with Java.
Recommended prerequisites
- Completion of Java SE 8 Programming training and Java SE 8 certification.
- Java SE 8 Programming.
Teaching and assessment methods
- Initial skills assessment
- Training materials provided to participants
- Continuous assessment throughout the course
- End-of-course feedback questionnaire
- Combination of theory and practical application
- Attendance records
- Post-course follow-up evaluation
Dates and sessions
Choose the date and delivery format that suit you.
No upcoming sessions are currently available.
fr
en