Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Java EE 7 Back-end Server Application Development: Communication and Security $74.95
Java EE 7 Back-end Server Application Development: JAXB and JAX-WS Web Services $74.95
Java EE 7 Back-end Server Application Development: Web Services $74.95
Java EE 7 Back-end Server Application Development: Business Logic $74.95
Java EE 7 Back-end Server Application Development: Getting Started $74.95
Java EE 7 Back-end Web Application Development: Transaction Support $74.95
Java EE 7 Back-end Server Application Development: Presentation with JSF $74.95

Bundle Price: $259.00
Total Savings: $265.65


Java EE 7 Back-end Server Application Development: Communication and Security

The Java Message Service is a Java API for sending and receiving messages. The API has variants for both Java SE and Java EE, with additional features such as JTA (XA) transactions available for Java EE. This course will cover the use of the JMS API in Java EE applications. It will cover the JMS messaging styles, how to handle messages synchronously and asynchronously, and the use of queues and topics as well as using EJBs as messaging clients. Message-driven beans (MDBs) are intended as message consumers and this course will also cover how to create and use MDBs in Java EE applications.
  • start the course
  • define the Java Message Service (JMS) API technology
  • describe the evolution of JMS
  • describe the features of JMS applications
  • describe the point-to-point (PTP) and publish/subscribe JMS messaging styles
  • describe the features of the JMS 2.0 simplified API
  • describe the features of JMS messages and how to handle messages synchronously and asynchronously
  • describe JMS queues and topics
  • describe the capabilities and limitations of EJB components as messaging clients
  • create a JMS message queue using Glassfish
  • create a web-based JMS queue producer and consumer
  • create an asynchronous Java SE client for a queue
  • practice developing Java EE applications using messaging
  • describe the properties and life cycle of a message-driven bean
  • describe how to create a JMS message-driven bean
  • describe how to configure a message-driven bean
  • create a JMS topic using GlassFish
  • create a JMS message-driven bean
  • use a publish/subscribe model with multiple message-driven beans
  • practice implementing MDBs in a Java EE application

Java EE 7 Back-end Server Application Development: JAXB and JAX-WS Web Services

Web services standards such as SOAP, WSDL, and UDDI are XML-based. This course will examine XML and how to manipulate it from within Java applications using JAXB – Java Architecture for XML Binding. It will go on to overview SOAP and demonstrate how to use JAX-WS – the Java API for XML Web Services – to generate web services that can be used for Java EE applications. The course will also cover how to create web service clients using both Java EE and Java SE.
  • start the course
  • describe the benefits of XML
  • describe the components of an XML document
  • describe the purpose of XML schemas
  • describe the benefits of JAXB
  • describe how to read and write XML data with JAXB
  • describe JAXB annotations
  • marshal a Java class to an XML file
  • marshal a Java collection to an XML file
  • generate a schema from Java source files
  • describe SOAP including SOAP requests and responses
  • describe how WSDL defines a web service
  • describe how JAX-WS is used to build web services and clients
  • describe how to create a JAX-WS web service
  • describe how to create a JAX-WS web service client using Java SE and Java EE, and use the client to call a web service
  • describe how to annotate SOAP web service methods
  • create and test a SOAP web service
  • create a Java web service client from a WSDL file
  • annotate SOAP web service methods and test the service
  • view SOAP messages
  • practice configuring JAX-WS services and clients

Java EE 7 Back-end Server Application Development: Web Services

The Java Naming and Directory Interface (JNDI) is an API that provides naming and directory functionality to Java EE applications, enabling components to locate other components and resources. This course will cover how to use JNDI in Java EE applications for instance referencing an EJB, or connecting to a database with JNDI. Enterprise Java Beans (EJBs) provide business and messaging functions in a Java enterprise application. Session beans are used for business functions and this course will cover how to work with different types of session beans in Java EE applications.
  • start the course
  • define JNDI, naming and directory services, and list JNDI packages
  • describe how to use JNDI
  • describe how to use JNDI names to refer to a database
  • reference an EJB using JNDI
  • set up a Java DB database
  • connect to a database without using JNDI
  • connect to a database using JNDI
  • describe the role of EJB components in a Java EE application
  • describe and contrast the features of EJB 3.0, EJB 3.1, and EJB 3.2
  • describe the different types of client access for session EJB components
  • describe the different types of session beans and their corresponding life cycles
  • describe how to package and deploy session beans
  • create a JAX-WS service with an EJB stateless session bean
  • create a remote interface with an EJB stateless session bean
  • practice configuring web services and remote interfaces with stateless session beans
  • define Contexts and Dependency Injection (CDI) against a backdrop of process without CDI
  • describe how CDI works and how to use it
  • compare EJB and CDI technologies
  • describe how to use CDI qualifiers to select between multiple implementations of an interface
  • describe how CDI is configured on a Java EE application server
  • describe how to use CDI producers and disposers
  • describe how to use CDI interceptors
  • describe how to work with CDI events and stereotypes
  • inject a bean with CDI
  • use CDI qualifiers for beans
  • practice injecting a bean with CDI and using CDI qualifiers

Java EE 7 Back-end Server Application Development: Business Logic

Concurrency in an application – the execution of two or more tasks at the same time – enables you to take advantage of multi-core processing and long wait times for external resources such as service calls or device access. This course covers how to implement the Java EE concurrency mechanisms including message driven beans, asynchronous EJBs, and the concurrency utilities for Java EE. The course goes on to review the implementation of the JDBC API in Java SE. It introduces Contexts and Dependency Injection (CDI) and covers how to use JNDI and CDI to access JDBC objects in Java EE. Atomicity, isolation, and flat threading are some of the transaction features that must be incorporated in applications compliant with the Java EE platform. This course concludes by covering transaction semantics and models for Java EE applications. It contrasts a programmatic and declarative implementation of transaction support and covers using JTA to scope transactions programmatically and implementing a container-managed transaction policy.
  • start the course
  • describe concurrency and contrast its implementation in Java SE and Java EE
  • describe the Java EE concurrency mechanisms
  • describe how to use asynchronous methods in EJB
  • use asynchronous EJB with no return values
  • use asynchronous EJB with return values
  • use the Java EE concurrency utilities
  • review the implementation of the JDBC API in Java SE and describe how to use JNDI and CDI to access JDBC objects in Java EE
  • describe how to use the Data Access Object (DAO) pattern to separate entity objects from the classes that manage data access
  • create and populate a Java DB database for a Java EE application
  • write data access objects with JDBC
  • describe the features of transactions
  • describe the different types of transaction models
  • contrast programmatic and declarative transactions and describe how to use JTA to scope transactions programmatically in Java EE applications
  • describe how to implement a container-managed transaction policy in Java EE
  • use bean-managed transactions in Java EE applications
  • use EJB container-managed transactions in Java EE applications
  • practice implementing transactions in Java EE applications

Java EE 7 Back-end Server Application Development: Getting Started

It's important to understand the architecture of a Java EE application and its development process. This course covers these areas and highlights the technologies involved in developing Java EE 7 Back-end Server applications. It also looks at standard Java technologies such as JavaBeans and annotations that can be incorporated into Java EE applications.
  • start the course
  • introduce Java EE technology group and the requirements of enterprise applications
  • describe enterprise application infrastructure technologies with separation of logic from services, and describe Java EE profiles
  • define Java EE technology specifications and how to access them and describe how they define APIs and also in some cases services
  • describe the Java EE requirement for a tiered architecture, the N-tiered model, and Java EE tiered architecture
  • describe the role of Java EE servers and the available implementations
  • describe the considerations for selecting a Java EE server and describe the benefits of the GlassFish server
  • describe the role of an IDE and list some of the IDEs that support Java EE development
  • describe the Java EE development process and the steps involved
  • describe Java EE containers and components
  • describe Java EE component state, properties, encapsulation, and proxies
  • describe the role of and different types of Java EE archive files including WAR and EAR files and list the web components in a WAR file
  • describe the use of deployment descriptor files in Java EE applications and list some vendor-specific deployment descriptors
  • install the GlassFish server from the NetBeans IDE
  • write a simple test application in NetBeans and deploy it to GlassFish
  • describe JavaBeans and how they can be used in Java EE applications
  • describe the considerations for creating and working with JavaBeans
  • describe Java logging and logging frameworks
  • describe how to use the java.util.logging.Logger class in Java EE applications
  • describe logging handlers in Java EE applications
  • referencing the GlassFish log service, describe how logging is configured and logs viewed for Java EE applications
  • create a Logger instance and add it to a Java EE application
  • describe and contrast the use of annotations with deployment descriptors in Java EE applications
  • describe the different types of annotations and how they are currently used in Java EE 7
  • describe annotation elements, placement, and retention in Java EE applications
  • describe method chaining and how it is used by JAX-RS
  • practice creating and working with loggers in a Java EE application

Java EE 7 Back-end Web Application Development: Transaction Support

Most business applications need to persist data. In this course, you will be introduced to the Java Persistence API, a lightweight framework that leverages Plain Old Java Objects (POJOs) for persisting Java objects that represent relational data. The course will cover JPA entities and entity mapping, the role of the Entity Manager, implementing CRUD Operations with entities, and using JPA queries. Bean Validation (JSR-349) is designed to provide a simplified data validation mechanism to Java applications by integrating validation in the life cycle of Java Beans components. This course covers how to implement bean validation with JPA. It describes the JPA life-cycle phases where bean validation takes place, and covers custom bean validation, injecting bean validation, and using validation groups.
  • start the course
  • describe at a high level the Java Persistence API and object-relational mapping it entails
  • describe JPA entities and describe how to create an entity class
  • describe entity mapping and the role of a primary key in mapping, describe how to change default mapping, and use temporal types and transient fields
  • describe the data types for fields and properties and contrast persistent fields and properties
  • describe the role of the Entity Manager with an example of its use in a Java EE application, and describe the entity instance life cycle and Entity Manager methods
  • describe persistence units and persistence contexts in Java EE applications
  • describe how to perform CRUD operations with entities
  • describe how to create queries with the Java Persistence Query Language (JPQL)
  • apply JPA to a Java EE application
  • describe the purpose of Bean Validation
  • describe the JPA life-cycle phases where Bean Validation takes place
  • describe how to implement custom Bean Validation
  • describe how to inject Bean Validation into Java EE components
  • describe how to use validation groups for Bean Validation
  • use Bean Validation with JPA
  • use a validator with Bean Validation
  • practice using Bean Validation with JPA in Java EE applications

Java EE 7 Back-end Server Application Development: Presentation with JSF

The EJB timer service is a container-managed service that provides a way to allow methods to be invoked at specific times or time intervals. This course covers how to implement both programmatic and automic timers in Java EE applications. It also covers how to implement batch processing, which is the execution of a series of jobs and is suitable for non-interactive, bulk-oriented, and long-running tasks. The second part of the course will cover security considerations for Java EE applications. The course will describe the Java EE security model. It will describe how authentication and authorization are applied in Java EE applications and will also describe the features of data integrity and how they can be applied in enterprise applications. You'll also learn about container-managed security and the use of roles and security groups. Finally, the course will demonstrate how to secure an enterprise application.
  • start the course
  • describe timer services
  • describe how to implement programmatic timers in Java EE applications
  • describe how to implement automatic timers in Java EE applications
  • describe batch processing and batch applications for the Java platform
  • describe how to implement batch processing in Java EE applications using the chunk-oriented processing pattern
  • implement batch processing in a Java EE application
  • describe security considerations for applications such as authentication, authorization, and confidentiality
  • describe the Java EE security model
  • describe how authentication and authorization is applied in Java EE applications
  • describe the features of data integrity and how they can be applied in enterprise applications
  • describe symmetric-key, asymmetric-key, and session-key cryptography, describe message digests
  • use the Java Keytool command
  • provide an overview of Java EE container-managed security
  • describe how roles are used in the Java EE security model
  • describe the use of SSL keys and HTTPS in client connections to application servers
  • describe web service security concerns and how to prevent attacks
  • describe web service security extensions
  • create a security group on a Java EE Application Server
  • create a Java class library project that contains the remote interfaces for a session bean
  • create and secure a Java EE enterprise application
  • create and run an application client
  • practice implementing security in a Java EE application
Register Now
Java EE 7 Back-end Server Application Development e-learning bundle
  • Course ID:
    271378
  • Duration:
    n/a
  • Price:
    $259