Overview
This Java EE 7: Front-end Web Application Development training helps you explore building and deploying enterprise applications that comply with the Java Platform, Enterprise Edition 7 Web Profile. Expert Oracle University instructors will help you explore annotations, Session Enterprise JavaBeans (EJB-Lite), Java Persistence API (JPA), servlets, JavaServer Pages(JSPs), Contexts and Dependency Injection (CDI), JAX-RS RESTful web services, the Java API for WebSocket and the Java API for JSON processing.
Learn To:
- Develop web-based interfaces for both desktop and mobile devices.
- Assemble an application.
- Build Java applications.
- Deploy an application into an application server (Java EE platform runtime environment).
Benefits to You
By taking this course, you'll gain hands-on experience building Java EE web applications. You will get the chance to create web-based user interfaces using HTML5 and JavaScript along with JSPs and servlets. Web-based user interfaces will use AJAX to communicate with RESTful web services you create; data will persist using JPA and optimistic locking.
Participate in Hands-On Labs
By learning through hands-on exercises via structured labs, you'll get a chance to explore EJB-Lite session bean components, which can be used with container-managed transactions. You'll perform lab exercises using the NetBeans IDE and WebLogic Server.
Who should attend
- Java Developers
- J2EE Developer
- Java EE Developers
- Web Administrator
Prerequisites
Required Prerequisites:
- Experience with Java SE, or Java Programmer Certification
- Understand object-oriented principles
- Basic understanding of database concepts and SQL syntax
- Able to author HTML, CSS, and JavaScript enabled web pages
- Java SE 8: Programming (D84838)
Suggested Prerequisites:
- Experience with an Integrated Development Environment
- !JavaScript and HTML5: Develop Web Applications (D84842)
Course Objectives
- Create and use Java annotations
- Select the correct Java EE Profile for a given application
- Develop and run an EJB technology application
- Create Java EE technology applications with the Java EE 7 Platform
- Identify the services provided by an Application Server
- Package, deploy and debug enterprise applications
- Create web-based user interfaces using Servlet, JSP, JAX-RS, and JavaScript technologies
- Access relational databases using the Java Persistence API
- Create scalable, transacted business logic with EJB-Lite
- Develop basic Java Persistence API entity classes to enable database access
- Develop a web-based user interface using Servlets, JSPs, and JAX-RS
- Design applications to use dependency injection
- Use IDEs and Application Servers for Java EE development
Product Description
- Java Platform, Enterprise Edition
- Enterprise Development Tools and Applications
- JavaBeans, Annotations, and Logging
- Java EE Web Architecture
- Developing Servlets
- Developing with JavaServer Pages
- JAX-RS Web Services
- Java RESTful Clients
- HTML5 Applications with JavaScript and AJAX
- WebSocket and the Java API for JSO Processing
- Implementing a Security Policy
- POJO and EJB-Lite Component Models
- The Java Persistence API
- Implementing a transaction policy
Outline
Java Platform, Enterprise Edition
- The Java EE Platform
- The needs of enterprise application developers
- Java EE specifications
- A comparison of services and libraries
- The Java EE Web Profile
- Java EE application tiers and layers
Enterprise Development Tools and Applications
- The purpose of an application server
- Starting and stopping WebLogic Server
- Properties of Java EE components
- The development process of a Java EE application
- Configuring and packaging Java EE applications
JavaBeans, Annotations, and Logging
- Java SE features used in Java EE applications
- Creating POJO JavaBeans components
- Using Logging
- Using Common Java Annotations
- Develop custom annotations
- The role of annotations in Java EE applications
Java EE Web Architecture
- The HTTP request-response model
- Differences between Java Servlets, JSP, and JSF components
- Application layering and the MVC pattern
- Avoiding thread safety issues in web components
- Use the Expression Language
Developing Servlets
- The Servlet API
- Request and response APIs
- Set response headers
- Two approaches to creating a response body
- Uploading files using a servlet
- Forwarding control and passing data
- Using the session management API
Developing with JavaServer Pages
- The role of JSP as a presentation mechanism
- Authoring JSP view pages
- Processing data from servlets in a JSP page
- Using tag libraries
JAX-RS Web Services
- The need for web services
- Designing a RESTful web service
- Create methods that follow the prescribed rules of HTTP method behavior
- Create JAX-RS resource and application classes
- Consume query and other parameter types
- Produce and consume complex data in the form of XML
- HTTP status codes
Java RESTful Clients
- Pre-JAX-RS 2 Clients: HttpUrlConnection and the Jersey Client API
- The JAX-RS 2 Client API
HTML5 Applications with JavaScript and AJAX
- HTML DOM manipulation with JavaScript
- RESTful clients with JavaScript (AJAX)
- Limitations of JavaScript clients
- The Same-Origin policy and CORS
WebSocket and the Java API for JSO Processing
- Web Service Limitations
- WebSocket Explained
- Creating WebSockets with Java
- Client-side WebSokect with JavaScript
- Client-side WebSocket with Java
- Consuming JSON with Java
- Producing JSON with Java
Implementing a Security Policy
- Container-managed security
- User roles and responsibilities
- Create a role-based security policy
- The security API
POJO and EJB-Lite Component Models
- The role of EJB components in Java EE applications
- The benefits of EJB components
- Operational characteristics of stateless and stateful session beans
- Creating session beans
- Creating session bean clients
The Java Persistence API
- The role of the Java Persistence API in Java EE applications
- Basics of Object-relational mapping
- The elements and environment of an entity component
- The life cycle and operational characteristics of entity components
Implementing a transaction policy
- Transaction semantics
- Programmatic vs. declarative transaction scoping
- Using JTA to scope transactions programmatically
- Implementing a container-managed transaction policy
- Optimistic locking with the versioning of entity components
- Pessimistic locking using EntityManager APIs
- The effect of exceptions on transaction state