Auto suggest in ADF for list of values

Using Auto Suggest for list of values

How to solve slowness issues in J Developer 12.2.1.3

Is your JDeveloper 12c too slow, follow these 3 basic steps and increase perfomance of JDeveloper 12c (12.2.1.3)

Step 1: Configure JVM settings in jdev.conf

Path: $MV_HOME$/jdeveloper/jdev/bin/jdev.conf

# optimize the JVM for strings / text editing

AddVMOption -XX:+UseStringCache

AddVMOption -XX:+OptimizeStringConcat

AddVMOption -XX:+UseCompressedStrings

# if on a 64-bit system, but using less than 32 GB RAM, this reduces object pointer memory size

AddVMOption -XX:+UseCompressedOops

# use an aggressive garbage collector (constant small collections)

AddVMOption -XX:+AggressiveOpts

# for multi-core machines, use multiple threads to create objects and reduce pause times

AddVMOption -XX:+UseConcMarkSweepGC

AddVMOption -DVFS_ENABLE=true

AddVMOption -Dsun.java2d.ddoffscreen=false

AddVMOption -XX:+UseParNewGC

AddVMOption -XX:+CMSIncrementalMode

AddVMOption -XX:+CMSIncrementalPacing

AddVMOption -XX:CMSIncrementalDutyCycleMin=0

AddVMOption -XX:CMSIncrementalDutyCycle=10

Step 2: Configure Jdeveloper memory settings in ide.conf

Path: $MV_HOME$/jdeveloper/ide/bin/ide.conf

# Set the default memory options for the Java VM which apply to both 32 and 64-bit VM's.

# These values can be overridden in the user .conf file, see the comment at the top of this file.

AddVMOption -Xms2048M

AddVMOption -Xmx4096M

remove settings from users file.

Step 3: Go to tools preferences, code editor and save action  Disable "Build After Save"

Dear All,
              I have successfully passed Oracle ADF 12c Certification examination. It was a very knowledgeable experience of giving 12c certification examination. 12c test was  very well organized as compared to 11g.
You can pass it only if you have development experience with theoretical knowledge. If you need further assistance feel free to contact with me. Kindly don't go for dumps they will surely leads towards failure.

ADF Certification

Dear All,
            I have completed my Oracle ADF Certification. Now I am Oracle ADF 11g Certified Implementation Specialist.I have never used any dump for exam preparation only focused on key concepts of ADF. Currently I am giving ADF trainings in Faisalabad and Lahore Pakistan anyone wants to get certified can contact me any time.

Online Training of Oracle ADF

we are offering online training of Oracle ADF. Training will cover all topics from basic level to advance level you will learn ADF and JDeveloper from industry experts who are  specialized in this field  and have developed ERP systems using cutting edge technologies like ADF,Webcenter and SOA.

Oracle ADF Training Course Contents

Topic 1: Introduction to Fusion and ADF Objectives
1. Describe Fusion Architecture.ss
2. Explain how ADF fits into the Fusion architecture.
3. Describe the ADF technology stack (MVC).
4. Identify sources of additional information about ADF and ADF Business Components.

Topic 2: Getting Started with JDeveloper Objectives
1. Describe benefits that JDeveloper provides for application development.
2. Utilize common IDE mechanisms when developing and testing components.
3. Set IDE preferences based on user requirements.
4. Initiate the creation of empty applications, projects, and connections in Jdeveloper.

Topic 3: Building a Data Model with ADF Business Components Objectives
1. Describe the role of ADF Business Components in building a business service.
2. Explain the architecture of ADF BC.
3. Identify the types of components that cooperate to provide the business service implementation.
4. Explain how ADF BC components are used in a Web Application.

Topic 4: Querying and Persisting Data Objectives
1. Describe the characteristics of an ADF BC view object.
2. Create a view object that can be used for performing a query in a Web application
3. Explain how entity objects relate to database tables.
4. Describe the persistence mechanism of entity objects.

Topic 5: Exposing Data to Clients Objectives
1. Explain the role of application modules.
2. Describe the characteristics of application modules.
3. Explain how application modules can manage business components transactions.
4. Explain how application modules can manage application state.
5. Explain the role of the ADF Model.
Topic 6: Declaratively Customizing Data Services Objectives
1. Declaratively change data behaviour.
2. Declaratively modify the default behavior of view objects, entity objects, and application modules.

Topic 7: Programmatically Customizing Data Services Objectives
1. Generate Java classes for business components to modify default behavior programmatically.
2. Override class methods to change or augment default behavior.
3. Modify the WHERE clause of a view object at run time.
4. Explain the benefits of adding service methods at the application module level (rather than at the view level).
5. Create a test client for testing your custom code.
6. Modify a view object's client code to add a new employee to the employees view object.

Topic 8: Validating User Input Objectives
1. Describe the types of validation available for ADF applications.
2. Evaluate which validation options are appropriate for different validations.
3. Add declarative validation for an entity object.
4. Identify the other non-declarative validation options and when they might be used.
5. Describe the benefits of using domains for validation.

Topic 9: Understanding UI Technologies Objectives
1. Describe the use of Web browsers and HTML.
2. Explain how Java has come into widespread use as a language for developing Web applications.
3. Describe the function of Servlets and JSPs.
4. Define JavaServer Faces.
5. Explain the JSF component architecture.
6. Expalin some JSF component types included in the standard implementation.
7. Describe the purpose of backing beans.
8. Describe the JSF life cycle.
9. Explain how ADF Faces augments the JSF life cycle.

Topic 10: Binding UI Components to Data Objectives
1. Create an empty JSF page.
2. Use three different ways to add ADF Faces UI components to a page.
3. Describe the types of data-bound components that can be added to a JSF page.
4. Describe the structure of an EL (Expression Language) expression.

Topic 11: Planning the User Interface Objectives
1. Describe the Model-View-Controller design pattern.
2. Differentiate between bounded and unbounded task flows.
3. Create task flows to define control flow in an application.
4. Specify control flow rules.
5. Define global navigation.
6. Use routers to declaratively route control flow to activities based on an EL expression.
7. Define the role of managed beans in task flows.
8. Explain the types of validation available in the user interface.

Topic 12: Adding Functionality to Pages Objectives
1. Internationalize the user interface so that the application can be used in multiple locales.
2. Use component facets to specify subordinate elements such as toolbars, headers and footers.
3. Implement a list of values (LOV) to enable users to select a value from a list.
4. Add a calendar component to an input date field to make it easy for users to select a date.
5. Use the table component to display structured data as a formatted table.
6. Employ the tree component to display hierarchical data.
7. Add icons and images to an application with ADF Faces output components.
8. Create Search forms using the ADF query component.
9. Use ADF Data Visualization components.

Topic 13: Implementing Navigation on Pages
1. Using ADF Faces navigation components
2. Using buttons and links
3. Using menus for navigation
4. Using breadcrumbs
5. Using a train component

Topic 14: Achieving the Required Layout
1. Using complex layout components
2. Explaining how to use ADF Faces skins
3. Using dynamic page layout

Topic 15: Ensuring Reusability
1. Designing for reuse
2. Using task flow templates
3. Creating and using page templates
4. Creating and using declarative components
5. Creating and using page fragments
6. Deciding which type of reusable component to use
7. Passing Values Between UI Elements

Topic 16: Defining the data model to reduce the need to pass values
1. Using a managed bean to hold values
2. Using page parameters
3. Using task flow parameters
4. Passing values from containing pages to regions

Topic 17: Responding to Application Events
1. Using managed beans
2. Coordinating JSF and ADF lifecycles
3. Using phase and event listeners
4. Using action listeners and methods
5. Understanding additional AJAX events

Topic 18: Implementing Transactional Capabilities
1. Handling transactions with ADF BC
2. Using task flows to control transactions
3. Sharing data controls
4. Handling transaction exceptions
5. Defining response to the Back button
6. Implementing Security in ADF BC Applications
7. Exploring ADF Application security options
8. Understanding ADF security framework
9. Enabling users to access resources
10. Implementing a Login page
11. Understanding ADF controller authorization
12. Using Expression Language to extend security capabilities

Topic 19: Explore the Project Structure and Core File Architecture
1. Defining File Structure of a Project
2. Examining Metadata Structure
3. Understand about Page Definition Files
4. Defining ADF Data Control and Data Binding Files
5. Exploring Connections
6. Exploring ADF Faces and Web Configuration files

Topic 20: Extend the ADF Business Components Framework
1. Examining general considerations when using ADF Business Components
2. Understanding Framework Classes and Framework Hierarchy
3. About PL/SQL in Business Components
4. DML and Database Views
5. DB Constraints, Compositions and Associations
6. Transactions with Compositions and Associations
7. Trigger assigned PK
8. Many-to Many relationships and Auditing

Topic 21: Use ADF Business Components for Validation, Calculations and List of Values
1. LOV View Objects
2. List Data Source
3. View Accessors
4. Transient Attribute
5. FK, Compare and Script Validations
6. Groovy code
7. View Criterias
8. Registering Business Rules

Topic 22: Use Inheritance in the Business Domain Layer
1. Implementing Inheritance
2. Domain Layer
3. Discriminators
4. Supertype/Subtype
5. Understanding Polymorphic Entity Usage
6. Creating Polymorphic View Rows
7. About Dynamic Rendering

Topic 23: Implement Data Binding Concepts
1. JSR-227 Data Controls and Bindings
2. Understanding ADF Model
3. Method, Accessor and Variable Iterators
4. Value and Action Bindings
5. DataBindings.cpx file
6. Synchronization
7. Data Control
8. Named Bind Variables

Topic 24: Practical Data Binding in Action
1. JSF & Data Model
2. ADFm Life Cycle
3. Custom Controllers
4. Customizing ADF Page Lifecycle
5. Custom Listeners
6. Conditional Values
7. Google-Style Query

Topic 25: Work with Managed Beans and JavaServer Faces
1. Expression Language
2. Understanding JSF Architecture and Life Cycle
3. About Component Model and Navigation Model
4. Managed Properties
5. JSF Value Binding
6. Backing Beans
7. Context Objects

Topic 26: ADF Faces Advanced Features
1. JSR-127 JSF Components
2. AJAX & Partial Page Rendering
3. PRP Attributes: partialSubmit, autoSubmit, partialTriggers
4. Runtime Layout
5. Page-Level Actions
6. Printable pages
7. Boolean Checkbox
8. Graphs and Charts

Topic 27: Introduction of Weblogic Server and Server Domains
1. Domain creation
2. Application server installation
3. Creating managed servers
4. Creating data source
5. Creating authenticators to implement security and login capabilities
6. deployment of EAR file

Training Duration
A. days (40 hours)
a. 3 hours a day

call a class method by clicking on submit button in adf

Completely follow these steps 

1: create a class named button class 

2:create a method named buttonAction in the button class

3: register button class as managed bean in adfc_config.xml file.

4:  go to jsf/jsp page click on the button button properties will be shown in property inspector

5:  go to property inspector and find action field click on the right side menu of action a popup will came

6: click on edit option another popup will be appeared select button class bean from managed bean lov

7: then select method from method lov

8: click ok

9: now go to button action function and print some thing

10: run page click on the button and see output from web logic console or j developer output console.

Show exact length of Secret data or Password in JSF Page in ADF

I have seen many posts about finding the solution of displaying exact length of password data in jsf page.
many people try to use af:inputText with secret=true; but fail and think that this is a bug from oracle.
I don't think this is bug this could be policy to increase security of data.

But If  there is a requirement from client to show exact length of secret data what to do know.
I have prepared a simple solution for this.

• create a view object or bean with property named password and type String.
• add this view object in data control.
• create a jsf page.
• add html component input secret like <h:inputSecret id="is1" value="" redisplay="true" immediate="true"/>
• bind value of input secret with view object property by going into page bindings or create a bean and bind with this bean like <h:inputSecret id="is1" value="#{bean.password}" redisplay="true" immediate="true"/>
• redisplay property should be set to true.
• deploy and test 

How to increase JVM Memory Size for JDeveloper 11g

Open the file D:\fmw1115\Middleware\jdeveloper\ide\bin\ide.conf

and change the lines

AddVMOption -Xmx1024M
AddVMOption -Xms128M

Also open the file D:\fmw1115\Middleware\jdeveloper\jdev\bin\jdev.conf

and change the line

AddVMOption -XX:MaxPermSize=256M

Online Training Courses Taught by Industry Experts 

Oracle ADF  Training

Oracle ADF Online Training | Oracle ADF Training

Introduction to Fusion and ADF

• Oracle ADF and JDeveloper
• • Oracle Fusion Middleware
• • Oracle Fusion Architecture
• • ADF and MVC
• • More about ADF

Exploring JDeveloper

• • JDeveloper 11g New Features
• • Building ADF Application in JDeveloper
• • Configuring JDeveloper Preferences

Database Schema Design

• • JDeveloper 11g New Features
• • Database Designing Tools in JDeveloper
• • Creating Offline Objects
• • Synchronize Online-Offline Database

Data Modeling with ADF Business Components

• • Advantages of ADF BC
• • ADF BC Categories
• • Creating ADF Business Components
• • Business Component Browser

Entity Objects and Associations

• • Data Persistence using Entity Objects
• • Creating Entity Objects
• • Modify Entity Object Default Behaviour
• • Associations
• • Groovy expressions
• • Validation Life Cycle
• • Built-in Declarative Validation Rules
• • Validation Execution
• Failure Handling
• Creating Validation Rule Class

View Objects and View Links

• Populating Data in View Objects
• Creating View Objects
• Modify View Object Default Behavior
• View Links
• Creating View Criteria
• Creating List of Values (LOV)
• Dependent LOVs

Application Modules

• Designing Application Module
• Creating Application Module
• Application Module Editor
• Testing Service Methods

Programmatically Modifying Default Behavior

• Supporting Java Classes
• Modify Entity Object Behavior
• Modify View Object Behavior
• Service Methods and Application Module

Introduction to User Interface Technologies

• User Interface – Available Technologies
• Java Server Faces
• ADF Faces

Understanding ADF Data bindings

• ADF Data Model and Bindings
• Exposing Business Components as Data Controls
• JSF Expression Language
• Binding Components to Data

Understanding ADF Task Flows

• Characteristics of ADF Task Flow
• Creating a Task Flow
• Using ADF Task Flow Components
• Using Method Call Activities
• Creating Managed Beans

Enriching the Page Content

• ADF Faces Rich Client Components
• Using Facets
• Using ADF Faces Components
• UI and Translation

Understanding Layout Basics

• ADF Faces Layout Components
• ADF Faces Skins
• Enabling PPR

Ensuring Reusability

• Pros and Cons of Reusability
• Reusing Components
• Designing for Reuse
• Creating ADF Library
• What Fits your Requirements

Implementing Page Navigation

• ADF Faces Navigation Components
• Performing Navigation
• Defining Access Keys
• Using Train Components

Handling Application Events

• JSF Page Life Cycle
• ADF Lifecycle Phases
• Creating Action Methods
• Value Change Events

Managing and Validating Data

• Holding Values in Data Model
• Holding Values in Managed Beans
• Passing Values between Pages
• Validation Event Points
• ADF Binding Validation
• ADF Faces Validation

Transaction Management

• Handling Transactions with ADF BC
• Transaction in ADF Task Flow
• Specifying Task Flow Transaction Start Options
• Creating Save for Later

Troubleshooting ADF Applications

• Logging and Diagnostics
• Java Logging
• ADF Logging
• ADF Declarative Debugger
• UI Troubleshooting Tools
• Configuring ADF Logging

Deploying ADF Applications (WebLogic)

• Creating a WAR Profile
• Creating a EAR Profile
• Testing the Server Connectivity
• Deploying the Application

 

JSF Tutorial

JSF 2.0 Tutorials

JSF 2 with Facelets and Ajax

Interested in training from the author of these tutorials? See the upcoming JSF 2.0 training course in Maryland, co-sponsored by Johns Hopkins Engineering for Professionals. Or, contact hall@coreservlets.com for info on customized JSF 1.x or JSF 2.0 courses at your location.

Following is a series of tutorials on JavaServer Faces version 2. Since each section includes exercises and exercise solutions, this can also be viewed as a self-paced JSF 2.0 training course. Click on a section below to expand its content.

Overview of the JSF 2.0 Tutorial Series

For most types of applications, JSF 2 is now the recommended way to build Java-based Web applications, replacing the older and lower-level servlet and JSP libraries. These tutorials cover JSF 2 using the Mojarra JavaServer Faces implementation and Apache Tomcat 6, but all of the code should run equally well with Apache MyFaces 2.0 (on any servlet 2.5 server) or on any Java EE 6 server. JSF 2 is dramatically better than JSF 1 in almost every way, and is both more powerful and easier to use. However, if your company is already developing in JSF 1 and is not yet ready to upgrade, the JSF 1.x tutorials cover JSF 1 with Apache MyFaces. Click on a topic below to get the detailed tutorial for that topic, download the section's source code as an Eclipse project, see exercises, get the source code for the exercise solutions, or to simply run the sample apps from that section. Practicing is the key to learning, so I strongly recommend that you try out a few of the exercises in each section before you peek at the solutions.
These tutorials are derived from Marty Hall's world-renowned live JSF 2.0 training courses. Customized courses on JSF are usually taught on-site at customer locations, but servlet, JSP, Ajax, GWT, JSF 2.0, Spring, Hibernate, RESTful Web Services, Android, and Java 6 training courses at public venues are periodically scheduled for people with too few developers for an onsite course. For descriptions of the various other courses that are available, please see the Java EE and Ajax training course page. To inquire about a customized training course at your location, please contact Marty at hall@coreservlets.com.
If you find these free tutorials helpful, we would appreciate it if you would link to us. Send corrections or feedback on any tutorial to hall@coreservlets.com.
Update 4/2011: Based on student feedback, I have simplified the programming basics section, broken the managed bean lecture into two pieces, added more simple/warmup problems to the exercises in each section, and put running versions of all apps (code from lectures as well as exercise solutions) online. The source code for the apps has been online to download from the beginning.

JSF 2.0: Introduction and Overview

This section gives the big-picture view of what JSF is all about, and summarizes why for most (but not all) applications, JSF 2 is generally a better choice than servlets and JSP, Struts, or other Java-based frameworks. It also discusses the various alternatives for adding Ajax support to Web applications, and how JSF 2 fits into that mix. Finally, it discusses the one and only clear-cut issue in the entire section: why JSF 2 is miles better than JSF 1 (both simpler and more powerful).

• This tutorial section in PDF.
• Exercises to reinforce the concepts in this section.
• Topics covered:
  • Different views of JSF
  • Pros and cons of JSF
    • Vs. standard servlet and JSP technology
    • Vs. Apache Struts
    • Vs. other Ajax approaches
  • New features in JSF 2.0
    • Vs. JSF 1.x

Installation, Setup, and Getting Started

This section describes the software and setup needed to run JSF 2.0 with Eclipse and either Tomcat (or any Java-based server support servlets 2.5 or later) or Glassfish 3 (or any Java EE 6 server). It also gives a brief example with annotated code. Adapting the setup to any other servlet 2.5 container or Java EE 6 server is quite simple.

• This tutorial section in PDF.
• Source code of examples in this section.
  • jsf-blank.zip An Eclipse project that contains all of the necessary pieces for JSF 2.0 (JSF 2.0 and JSTL 1.2 JAR files in WEB-INF/lib, entries in the web.xml file, and a blank faces-config.xml file). It also has the JSF 2.0 Eclipse facet added, so if you import it into Eclipse 3.6 (Helios), you will get extra help when editing the .xhtml files (R-click and choose Open With, Web Page Editor) and faces-config.xml (just double click it). If you use this as a starting point for your JSF 2.0 apps, then nothing else is needed other than code specific to your application. This one project is all you need to start with JSF 2. Runs on any server that supports servlets 2.5 or later (e.g., Tomcat 6+, Jetty 6+, Google App Engine, JBoss 5+, WebSphere 6+, WebLogic 9+). If you will deploy only to Glassfish 3, JBoss 6, or other Java EE 6 servers, delete the JAR files in WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Topics covered:
  • Required software
    • Installing Java SE 6
    • Installing Eclipse 3.5
    • Installing a server for JSF 2.0
      • Tomcat 6 or other servlet 2.5 container (also needs jsf-api.jar and jsf-impl.jar) or
      • Glassfish 3 or other Java EE 6 server
  • Testing projects
    • Importing and testing an existing JSF 2.0 project
      • Deploying on Tomcat and Glassfish
    • Making your own JSF 2.0 project
  • Sneak preview of basic features
    • Summary of code in jsf-test project

New Features in JSF 2.0

I'll admit it: I didn't like JSF 1 either. So, when JSF 2 came out, I had low expectations. But, when I looked at the beta version, I was very pleasantly surprised that they learned lessons from Ruby on Rails, JBoss Seam, and the Ajax4Jsf library. And, now that I have used it much more and seen many of the features that support today's modern applications, I have concluded that JSF 2 is probably the overall-best mainstream Java-based Web app framework now in existence.
Here is a very brief summary of the most important features that are new in JSF 2.0 (but not in JSF 1.x). Details on all of these topics are covered throughout the rest of the lectures. This section is mostly only useful for people who used JSF 1.x; if you are new to JSF, start with the two sections above, then move on to the programming basics section.

• You have more debugging help during project development. To get started with JSF 2.0, at the very least you need a web.xml with a url-pattern for *.jsf or something similar, and a faces-config.xml with valid start and end tags, just as in JSF 1.x. However, in JSF 2.0, you can optionally add a PROJECT_STAGE setting of Development to web.xml. By doing this, many errors that would silently fail in JSF 1.x now result in explicit error messages.
• Facelets, not JSP, is the standard technology for all your JSF pages. Name the pages blah.xhtml, but use the URL blah.jsf (assuming a url-pattern of *.jsf in web.xml). Use xhtml format for the pages themselves. Don't use @taglib, but instead use xmlns:h="http://java.sun.com/jsf/html". Then, use h:head, h:body, and h:form (but not usally f:view) in the page. You can find a representative sample here.
• You can use default bean names. Instead of declaring beans with managed-bean in faces-config.xml, you can put @ManagedBean above the class definition. Then, take the bean classname, change the first letter to lower case, and use that as the managed bean name. For example, if the class is package1.package2.MyBean, you would use #{myBean.whatever} in your code. You can also do @ManagedBean(name="someName"). Beans are request scoped by default, but there are annotations like @SessionScoped to change the default. This sample bean and the sample .xhtml page from above illustrate this.
• You can use default mappings of outcomes to results pages. In the absence of explicit navigation rules, the return values of the action controller method correspond to the file names that should be used. Suppose that your form (file form.xhtml, URL form.jsf) says <h:commandButton ... action="#{someBean.someMethod}"/>. When the button is pressed, the bean named someBean is instantiated (assuming request scope), setter methods corresponding to the h:inputBlah elements are run, validation occurs, and then someMethod is executed. This is the same as in JSF 1.x, except that the managed bean name (someBean) can be derived from the bean class name (SomeBean). But now, if someMethod returns "foo" and "bar", and there are no explicit navigation rules in faces-config.xml for those outcomes, then JSF will assume that they correspond to foo.xhtml and bar.xhtml (from the same folder as form.xhtml), respectively. For example, in the this sample bean, the outcomes correspond to accepted.xhtml and rejected.xhtml. In a later section on page navigation, I will argue that explicit navigation rules are probably what you will use in real projects, but the implicit navigation lets you get your app up and running more quickly, and is particularly convenient for test apps where you just want to experiment with some particular JSF 2 feature.
• You can usually use #{myBean.myProperty} instead of <h:outputText value="#{myBean.myProperty}"/>. If you don't need any fancy options, the first form is much more concise. Both forms escape HTML characters, and thus can be used for properties containing user input. You only need h:outputText when you need escape="false" or want to compute the render property or need to assign an id or want use another less-common feature of h:outputText.
• You can easily Ajaxify your application. Add xmlns:f="http://java.sun.com/jsf/core" to the page header. Inside the start and end tags for h:commandButton, put <f:ajax execute="@form" render="resultId"/>. Then, also have <h:outputText value="#{myBean.myProperty}" id="resultId"/>. This means that when the button is pressed, all the form elements are sent to the server and executed normally. Then the action controller method is executed normally. Then, the value of getMyProperty is computed and sent back to the server. JavaScript receives the value and inserts it into the current page in the place where the h:outputText element initially was. A later section covers the Ajax support in detail.
• Mere mortals can build custom components. In JSF 1.x, the existence of an API for custom components was a real boon. Because of it, a whole market for third-party component libraries developed, with PrimeFaces, RichFaces, IceFaces, Tomahawk, ADF, and Web Galileo being notable libraries. However, the API was so complex that it was more trouble than it was worth for most ordinary JSF programmers. Now, there is a very easy-to-use facelets-based (rather than Java-based) method for building simple and medium-complex components. This is somewhat analogous to the tag-file way of building JSP custom tag libaries, but even simpler and even more powerful. A later section covers composite components in detail.
• There is a powerful and relatively easy to use page templating library (better than Tiles!). JSP always had jsp:include, but it lacked a serious library for building page templates, sub-templates, and concrete pages built upon templates. However, most modern Web apps have many similar-looking pages, so templating is a must. JSF 2 has a well-thought-out, extensible, and moderately easy-to-use templating framework that is arguably even better than Apache Tiles on which it was loosely based. A later section covers page templating in detail.

JSF 2.0: Programming Basics

This section covers basic JSF programming. In this part, we use Java-based annotations and default (implicit) mappings of action-controller return values, and do not use the faces-config.xml file at all. This is the first section where it is particularly important that you practice by trying out projects that follow this approach. See the exercises below. This is also a good section to read if you know JSF 1.x but have never seen the JSF 2.0 annotations. However, make sure you read the installation/setup section first so that you know how to create and deploy JSF 2 apps.

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section. I strongly recommend that you try out at least a few of the exercises before moving on to later sections.
• Source code for exercise solutions. A downloadable Eclipse project containing the solutions to the exercises above. But try the exercises yourself before peeking!
• Topics covered:
  • Simplified flow of control
  • @ManagedBean and default bean names
  • Default mappings for action controller return values
  • Using bean properties to handle request parameters
• Running apps. Downloading the source code (above) and using it for your own apps is probably what most developers want to do. But if you just want to see the apps in action, try the following links.
  • App from the lecture
  • Exercise solutions

Managed Beans I: Using Java Classes to Represent Form Info

This section gives more details on the managed beans that were introduced in the Programming Basics section.

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Basic beans and "managed" beans
  • Three parts of beans in JSF
    • Getter/setter methods to represent input elements
    • Action controller method
    • Placeholder for results (properties derived from input)
  • Prepopulating input fields
    • And building comboboxes (drop down menus)
• Running apps:
  • App from the lecture
  • Exercise solutions

Managed Beans II: Advanced Features

This section covers some of the important but lesser-used features of managed beans.

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Custom bean names
  • Bean scopes
    • Especially session-scoped beans
  • Getting the "raw" request and response objects
  • Dependency injection
• Running apps:
  • App from the lecture
  • Exercise solutions

Explicit Page Navigation and faces-config.xml

This section covers the use of faces-config.xml for two main tasks: giving navigation rules (rather than using the default mappings where the action controller return value corresponds to the results page names) and declaring beans (rather than using @ManagedBean). It also covers wildcards in navigation rules, static navigation, and common navigation problems.

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Basic navigation rules
  • Explicit bean declarations
  • Advanced navigation options
    • Wildcards in navigation rules
    • Conditional navigation rules
    • Dynamically computed to-ids
  • Static navigation
  • Common navigation problems
• Running apps:
  • App from the lecture
  • Exercise solutions

The JSF 2.0 Expression Language

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Motivating use of the expression language
    • Comparing to the JSF 1.x and JSP 2.0 ELs
  • Accessing bean properties
    • Direct
    • Nested
  • Submitting bean properties
    • Expressions in output values
    • Expressions in submission values
    • Expressions for action controllers
  • Accessing collection elements
  • Using implicit objects and operators
  • Passing arguments to methods
• Running apps:
  • App from the lecture
  • Exercise solutions

Properties Files and Internationalization (I18N)

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Creating properties files
  • Declaring properties files in faces-config.xml
  • Simple messages
  • Parameterized messages
  • Internationalized messages
• Running apps:
  • App from the lecture
  • Exercise solutions

Handling GUI (Application) Events

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Motivation
  • Comparing action controllers to action listeners
  • Action listeners
  • Value change listeners
  • Using JavaScript to submit form
    • Dealing with browser incompatibilities
• Running apps:
  • App from the lecture
  • Exercise solutions

Integrated Ajax Support in JSF 2.0

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Motivation
    • Web apps in general
    • Ajax in general
    • Ajax integrated with JSF 2.0
  • Using f:ajax
    • Overview
    • render: specifying elements to update on client
    • execute: specifying elements to process on server
    • event: specifying user events to respond to
    • onevent: specifying JavaScript side effects
    • Limitations on the use of h:outputText with Ajax
• Running apps:
  • App from the lecture
  • Exercise solutions

Validating User Input

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Manual validation
    • Validation in the action controller method
  • Implicit automatic validation
    • Type conversion and the "required" attribute
  • Explicit automatic validation
    • Using f:validateLength, f:validateRegex, etc.
  • Defining your own validation methods
    • Then using the "validator" attribute
• Running apps:
  • App from the lecture
  • Exercise solutions

ui:repeat and Handling Variable-Length Data

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Options for handling variable-length data
    • Building strings or simple HTML from a bean property
    • Using a builtin component like h:dataTable
    • Making your own composite component
    • Looping with ui:repeat
  • Using ui:repeat
    • Simple loops
    • Nested loops
    • varStatus
    • Conditional output
      • <h:outputText rendered="…" …/>
      • <ui:fragment rendered="…">…</ui:fragment>
• Running apps:
  • App from the lecture
  • Exercise solutions

h:dataTable -- Building Tables from Collections

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Options for handling variable-length data
    • Building HTML from a bean property
    • Using a builtin component like h:dataTable
    • Making your own composite component
    • Looping with ui:repeat
  • Using h:dataTable
    • Basics: h:dataTable and h:Column
    • Headings
    • Style sheets
    • Ajax-enabled tables
    • Tables with conditional values
• Running apps:
  • App from the lecture
  • Exercise solutions

Composite Components

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Idea
  • Basic components
  • Passing values to components
  • Using ui:repeat inside components
  • Nested components
  • Handling relative URLs in components
• Running apps:
  • App from the lecture
  • Exercise solutions

Page Templating with Facelets

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Motivation
  • Basic mechanism
    • Template file
    • Client file
  • Templating with includes
  • Handling relative URLs
    • And relocatable resources
• Running apps:
  • App from the lecture
  • Exercise solutions

View Params, GET Requests, and Bookmarking

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Source code for exercise solutions.
• Topics covered:
  • Motivation
    • Why support GET?
  • Using f:viewParam
    • To capture incoming request parameters
  • Using h:link and h:button
    • To send outgoing request parameters
  • Using non-JSF forms
    • To send data to JSF pages that use f:viewParam
  • Using POST-redirect-GET
    • To make JSF results pages bookmarkable
• Running apps:
  • App from the lecture
  • Exercise solutions

Using Spring in JSF 2.0 Applications

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Exercises to reinforce the concepts in this section.
• Topics covered:
  • Fast review of Spring dependency injection
  • Configuring a JSF/Spring project in Eclipse
  • Defining beans in two places
    • JSF backing beans in faces-config.xml
    • Spring beans in applicationContext.xml
  • Defining beans in one place only
    • All beans in applicationContext.xml
• Running apps:
  • App from the lecture
  • Exercise solutions

JSF 2.0: A Whirlwind Tour of New Features

This section gives a quick summary and sample code for some of the most important new features that were added to JSF 2. This is probably only helpful for developers that have used JSF 1.x. Developers that are new to JSF entirely should start with the overview and getting started sections, then move through the other sections in order.

• This tutorial section in PDF.
• Source code of examples in this section, bundled as an Eclipse project. If you deploy to Tomcat 6 or another servlet/JSP engine supporting servlets 2.5 or later, use the project exactly as is. If you deploy to Glassfish 3, JBoss 6, or another Java EE 6 server, delete the unneeded JAR files from WEB-INF/lib.
• Topics covered:
  • Setup review
  • New facelets page format
  • New annotations for managed beans
  • New default mappings of return values to results pages
  • Old-style explicit mappings of return values to results pages
  • New, more concise way to output bean values
  • New support for Ajax and incremental page updates

Other JSF 2.0 Features

Coming soon. We regularly add coverage of additional topics. Email me at hall@coreservlets.com if you have strong opinions about which features should be covered next.

Source Code

Source code for all examples in this tutorial as well as the exercise solutions can be downloaded from the JSF 2 sample code repository. Code is free for completely unrestricted use. Each section above also has links to the code used in that section.

PowerPoint Files for University Faculty

The PDF files in this tutorial contain the complete text of the original PowerPoint files, so if your goal is learning this technology, just stick with this tutorial. However, as a service to instructors teaching full-semester courses at accredited universities, coreservlets.com will release the original PowerPoint files for free. Please see the instructor materials page for details.

More Information