Building Java EE Web Applications using Java Servlets, JSP and JSF
Instruction Language: Turkish/English
Duration: 5 days
This course provides all the information required to build applications containing dynamic web content using the Java Servlets and JavaServer Pages and Java Server Faces. Java Servlets allow flexible generation of dynamic content without the limitations of CGI-based applications or those created in a web server-specific manner. The JavaServer Pages technology allows one to separate static from dynamic content while harnessing the power of Java Servlets.
JavaServer Faces (JSF) provides event driven, component –based technology for developing J2EE web applications. This technology greatly simplifies developing web applications. Finally, Java web developers can assemble reusable UI components into rich GUI pages. A standard UI component model will create a rich third party market of reusable GUI components. Throughout the five day course students will be led through a series of progressively advanced topics, where each topic consists of lecture, group discussion, comprehensive hands-on lab exercises, and lab review.
Who benefits? This is an intermediate level Java programming course, designed for developers who wish to create dynamic HTML content using Server Side Java and JSF. Attending students should be able to use the syntax of the Java language without difficulty. Familiarity with the behavior of accessing web content from the perspective of the end user is also helpful.
Java Servlets and JavaServer Pages are essential server-side Java technologies for building web applications. Servlets are programs that run on a web server; they can respond to client requests and create dynamic content. JavaServer Pages are useful for dividing work between Java developers and HTML designers. This course is a comprehensive tutorial in the design and programming of servlets and JSPs. Students will learn about the capabilities of servlets, Servlet architecture, and session management. They will learn about JSP syntax, deployment, and application models, how to use Java as a scripting language (or not!), and how to build robust and capable web applications using Servlets and JSP.
A correct architecture and design is paramount. That's why we explain all technologies within the Model 2 architecture (de de-facto standard, which is also followed by frameworks like Struts and Maverick). So we will not explain Servlets and JSP as a list of technologies as they where specified chronically, but always within its architectural context. You will learn all technologies. Among the technologies that you will learn are: Servlets, JSPs, Filters, Events, Custom Tags, deployment and configuration of your Server, important J2EE View Patterns and much more!
Course content (Trivera course catalogue)
Session: Introduction to Java EE Web applications
Lesson: Introduction
- Understand the concept of dynamic web applications
- List the Web technologies in Java EE 5
- Understand for each their purpose and architectural position
- Get an overview of the deployable unit of a web application
- Explain the principles of Servlet and JSP
- Introduce JSF
Lesson: Introduction to Servlets and JSP
- Introduce the Model 2 architecture (MVC for the web)
- Understand the architectural relation between Servlets and JSP
- Understand the responsibilities and typical implementation technology of each element in the Model 2 architecture
- Understand how to write a Servlet to process a form
- Understand how to configure a Servlet in the web.xml deployment descriptor
- Understand the basic Servlet API
- Understand how to write a JSP
- Understand the different techniques available in JSP
- Introduce attributes, their scope and their role in the Model 2 architecture
- Introduce the use and syntax of Unified Expression Language
- Introduce JSP standard actions
- Introduce JSTL
- Mention and discuss language based scripting
Session: Java EE Web Applications
Lesson: Configuration (Databases, EJB and configuration data)
- Adding ServletContext parameters
- Data access in Web Applications
- Accessing resources (e.g., Datasources) using Dependency injection (DI)
- Discuss shortcomings of DI
- Explain the process of a JNDI lookup
- Use the DAO (Data Access Object) pattern
- How to locate EJB.
Lesson: Session Management
- Client side session management using cookies
- Understand HTTP cookies
- Understand under which criteria cookies are accepted
- Server side session management using HttpSession object
- Understand the architectural impact when using server side state management (fail-over, server affinity, session replication etc)
- Understand the two web-application life-cycle listeners
- Understand the three session life-cycle listeners
- Understand when to use an HttpSessionBindingListener
Lesson: Security
- Understand the security tasks and how they are addressed in Java EE
- Understand how to establish proof of identity in web applications
- Understand how to restrict access to parts of the web application
- Understand how to establish data integrity and privacy
- Explain the configuration of security and the power of indirection
- Understand Users, Groups & Roles
- Understand role based security
- Understand principal mapping strategies
Lesson: Programming Java EE Filters
- Understand the concept of filtering and chaining of filters.
- List the three methods of the javax.servlet.Filter Interface and explain their purpose
- Configuring a Filter in the deployment descriptor
- Understand the rationale behind the interceptor pattern
- Understand the use of the Wrapper pattern in Filters
- Understand how to use the HttpServletRequestWrapper and theHttpServletResponseWrapper
Lesson: Introduction to Custom Tags
- Understand the proposed architectural role of Custom Tags
- List the components that make up a Custom Tag
- Understand the rationale behind the TLD file
- Understand how to make a deployable unit of your Tag Library
- Understand how to deploy a Tag Library in your web applications
- Understand the possible need for further validation of tag usage using TEI and Validators
- How to declare and enable attributes to your tag
- How to declare scripting variables
Session: Introduction to JavaServer Faces
Lesson: Introduction
- Introduce JavaServer Faces
- Explain the benefits of the JavaServer Faces technology
- Provide a global overview of the JSF architecture
- Introduce the building blocks of a JSF application
- Define the development roles during the development of a JSF application
- Explain the use of IDEs for building JSF applications
- Explain the role of MVC within JSF
- Define the view components of JSF
- Define the controller components of JSF
Lesson: Creating a basic JSF application
- Introduce the JSF development environment
- Configure the JSF servlet in the web.xml
- Introduce some of the JSF tags for building JSP pages
- Create a basic JSP page, using JSF tags
- Create a backing bean
- Define page flow in the faces-config.xml file
- Define the backing bean in the faces-config.xml file
Session: JSF Component Model
Lesson: JSF UI Components
- Understand the component architecture of JSF
- Explain the use of the RenderKit
- User Interface Component Model
- Introduce the JSF Custom Tags
- Explain the functionality of the various input tags
- Panels and tables in JSF
Lesson: Managed Beans & Backing Beans
- Develop an backing bean to support a JSP page
- Store UI component values in a managed bean
- Store UI component references in the backing bean
- Configure beans using the managed bean creation Facility
Lesson: JSF Navigation Model
- Explain the JSF Navigation Model
- Configure Navigation Rules in the faces-config.xml
- Implement action methods to handle navigation
Session: JSF Life-cycle
Lesson: JSF Data Conversion
- Using standard data conversion
- Writing custom data conversion
Lesson: JSF Validation
- Introduce the Standard Validation components
- Add validation to user input
- Display validation messages
- Creating Custom Validation components
Lesson: Understanding the JSF life-cycle
- Explain the position of the JSF controller servlet within the JSF framework
- Explain the phases of the request-response life-cycle
- Define the role of the developer in each phase
- Define the role of the system in each phase
- Explain the request processing life cycle scenarios
- Explain the FacesContext
- Using FacesContext.renderResponse
Lesson: JSF Event and Listener Model
- Create an event listener
- Explain the three ways to handle an event
- Register event listeners to JSF components