Course Summary
JSF on Spring and Hibernate training course takes students beyond the fundamentals of Servlet/JSP/JDBC development into the realm of event-driven, component-oriented, rich Java web applications with the JavaServer Faces technology bolting it on top of best-of-breed Spring/Hibernate open source stack.
Through a tutorial-style hands-on delivery students learn the concepts behind the JSF technology, including its architecture, API, life-cycle, components, converters, validators, renderers, listeners, event-handling, expression language, configuration, deployment, integration with Spring and Hibernate, and its relationship to Servlets/JSPs and other MVC frameworks.
In addition to using standard off-the-shelf JSF components (e.g. tables), students also gain skills necessary to build custom components, validators/converters, and AJAX-enabled user interfaces - all while applying best-practices in their overall application design.
Duration
4 days.
Objectives
After successfully completing this course, students will be able to:
- Utilize component-oriented development techniques
- Work with standard of-the-shelf JSF components
- Develop custom components, validators, and converters
- Take advantage of third-party components, IDEs, and open-source add-ons
- Put it all together in a JSF application
- Build AJAX-enabled user interfaces
- Integrate JSF with Spring IoC (and Hibernate)
- Integrate JSF with existing applications and MVC rameworks (e.g. Struts)
- Apply best-practices to JSF projects
Audience
Students must be familiar with the Java programming language and have a basic understanding of Java web application development concepts, including Servlets and JSPs.
Prior familiarity with Spring, Hibernate, and other MVC frameworks such as Struts is not required but can be helpful.
Additional Notes
This course is typically taught using Eclipse IDE and Tomcat Servlet engine. Other IDEs (e.g. NetBeans) and application servers (e.g. JBoss) are also supported, but have to be explicitly requested.
Java™ and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. Hibernate™ is a registered trademark of Red Hat, Inc. Apache™ and Tomcat™ are a trademark of The Apache Software Foundation and are used with permission. Spring™ is a trademark of SpringSource, Inc. Marakana does not have any affiliation with these companies.
Outline
Day 1: Introduction
- An introduction to JSF
- Overview
- Servlets, JSP, and Frameworks
- Web frameworks use the MVC pattern
- Many different frameworks
- What is JavaServer Faces?
- JSF and Struts
- JSF Application Architecture
- The IDE Effect
- Key JSF Concepts
- User interface (UI) components
- Renderers
- Backing beans
- Validators
- Converters
- Events and listeners
- Navigation
- Expression language (EL)
- Messages
- Application Requirements
- Developing an Application
- Demonstration: Hello, world! with a WYSIWYG JSF IDE
- Summary
- Exploring the JSF landscape
- Overview
- Java web development: the old daze
- Flip Side: Components and ASP.NET
- Rise of the JSF Ecosystem
- Stats: Products, Articles, Books, Resources
- Ecosystem players
- JSF Implementations
- Development tools
- 3rd Party Components
- Frameworks built on JSF
- Integration
- Open source/free tools
- JSP alternatives
- Comparing markets
- Summary
- Getting Started with JSF
- Overview
- Key JSF Concepts Revisited
- Key artifacts
- High-level Architecture
- JSF Applications are Web Applications
- Front Controller Pattern
- JSF Front Controller
- Configuration – web.xml
- JSF Configuration Files
- JSF Navigation
- Navigation Elements
- JSF Navigation Interactions
- Navigation Rule Editors
- Example Navigation Rules
- Developing the view
- Configuring a JSF Welcome Page
- Developing Views with JSP
Day 2: Standard Features
- Creating Backing Beans and using Managed Beans
- Overview
- The JSF Expression Language
- JSF EL vs JSP EL
- Managed Beans
- Managed Bean Configuration
-
- JSP <usebean> vs JSF Managed Bean
- Managed Properties
- List Properties
- Map Properties
- Lists and Maps as Managed Beans
- Advantages of Managed Beans
- Wiring up Beans with the EL
- Backing Beans ? Managed Beans
- Backing Beans
- Bean Development Tips
- Writing a Backing Bean
- Configuring a Backing Bean
- Exploring the Standard Components
- Overview
- The Standard Component Set
- Using HTML Attributes
- Understanding Facets
- Common UI Component Properties
- Output Component Family
- Panel Component Family
- Form Component Family
- Input Component Family
- SelectBoolean Component Family
- SelectItem Component Family
- SelectMany Component Family
- SelectOne Component Family
- Command Component Family
- Data Component Family
- Internationalization, Validators, and Converters
- Overview
- Internationalization (i18n) and localization (l10n) in JSF
- Definitions
- Internationalizing and Localizing an Application
- Validation
- Validator Methods
- Using Validators
- Standard Validators
- Handing type Conversion
- Using Converters
- Standard Converters
- Customizing Messages
Day 3: Application Development
- Developing with JSF
- Overview
- Key JSF Objects
- Key Application Objects
- Key Context Objects
- Key Event Objects
- Writing ActionListeners
- Writing ActionListener Methods
- Writing ValueChangeListeners
- Writing ValueChangeListener Methods
- Securing Web Applications
- Container Based Security
- Disadvantages of Container Security
- Custom Security - Authentication and Authorization
- Integrating the Web Tier
- Integrating Other Tiers
- Don't Forget the Servlet API
- Development Tips
- Inside the JSF Architecture
- Overview
- Powerful Architecture
- The Request Processing Lifecycle
- Phase Listeners
- Pluggable Extension Points
- Extension Point Overview
- Configuring Pluggable Classes
- Decorating a Pluggable Class
- Replacing a Pluggable Class
- Writing Custom Components, Validators, and Converters
- Overview
- UI Extensions
- Developing UI Components
- When to write a UI Component
- UI Component Artifacts
- Developing Renderers
- When to write a Renderer
- Renderer Artifacts
- Developing Validators
- When to write a Validator
- Validator Artifacts
- Developing Converters
- When to write a Converter
- Converter Artifacts
Day 4: Integration
- Component Frameworks Overview
- Overview
- AJAX in JSF with AJAX-enabled components
- Why use 3rd-party components?
- Overview and Examples of Open Source Component Suites
- ICEsoft ICEfaces
- Apache MyFaces Tomahawk, Trinidad, and Tobago
- JBoss RichFaces
- Oracle ADF
- Overview of Commercial Component Suites
- Simplica ECruiser
- Infragistics NetAdvantage for JSF
- TeampDev QuipuKit
- SoftAspects WebGalileo Faces
- Can’t we all get along?
- Which one?
- Spring and Hibernate
- Overview of Inversion of Control (IoC) design pattern
- Overview of Spring
- Background
- IoC in Spring
- Installation
- Configuration
- Wiriting Beans
- Best Practices
- JSF and Spring integration
- Configuration
- Best Practices
- Overview of Hibernate
- Why OR/M?
- Overview of JPA
- Basic mapping, Session API, etc.
- Integration with Spring
- Wrapping it all together
- Summary and Future Directions
