OraNA :: Java Tools and Frameworks

Applying View Criteria from Application Module

Andrejus Baranovskis — Sat, 13 Mar 2010 08:56:12 PST

Often we need to define and invoke View Object filtering. In ADF 11g we can do this by adding WHERE clause to View Object SQL statement or by defining View Criteria and invoking it later. I prefer second approach, why I should play with SQL statement, if ADF 11g can generate it for me. Okej, when there is View Criteria, it should be invoked. There are different approaches to do this - from declarative to programmatic. Today I will describe my preferred approach, I'm not saying you should use it as well.

Download sample application - AppModuleQuery.zip. This sample implements View Criteria to filter employees based on their department:

Here is the first trick - I have defined Bind Variable setter method to pass variable value and exposed this method through client interface:

This means I will call it later from Controller layer to pass correct Bind Variable value. Its important to say, you should do ExecuteQuery when new Bind Variable is passed, this will ensure it will be correctly reinitialized:

Now most interesting part starts, you can declare View Criteria to be executed automatically, each time when View Object is accessed. You can do this in Application Module - select View Object from Data Model section and click Edit:

Select View Criteria you want to trigger automatically - it will be invoked each time when View Object will be accessed:

Model part is done, now its time to look into Contoller. As you remember, Bind Variable setter method was exposed through client interface, it is present in Data Control:

Drag and drop it into ADF Bounded Task Flow, it is needed to set correct Bind Variable value. In my case it is defined as Default Activity:

On runtime, JobId value is passed as Input Parameter for ADF Bounded Task Flow, where it is used for Bind Variable setter method parameter:

ADF Bounded Task Flow is opened, Bind Variable value is set and View Criteria applied automatically:

Jersey 1.1.5.1 released

Gerard Davison — Thu, 11 Mar 2010 04:35:12 PST

There is a minor point release of Jersey that includes a pair of significant bug fixes for weblogic and JDeveloper users. Worth using in preference to 1.1.5. Thanks a lot to Paul for putting this one together.

A Reader Asks - How To Pass Table Export Id Into ADF 11g Declarative Component

Andrejus Baranovskis — Wed, 10 Mar 2010 10:36:27 PST

"I'm trying to use ExportCollectionActionListener inside Declarative Component, but I can't pass table export Id correctly - it gives error, Id is not found. Is it possible to make it work?"

Yes, it is. Download sample application - DCLibExport.zip. This archive contains two JDeveloper 11g applications - Declarative Component (ExportToolbarLib) and consuming application (EmployeesExport). I will not talk about Declarative Components in this post, you can read more about them from previous post.

Declarative Component example is really simple, it contains one attribute - exportId. Such type of components are really useful for proper application design and architecture, it allows to achieve proper reusability - instead of declaring Export buttons for each table, we are doing it only once:

And one button with ExportCollectionActionListener assigned, this will allow to export table data to Excel format automatically:

Important thing to mention - ExportCollectionActionListener gets ExportedId property value from Declarative Component attribute:

This means, we will be able to provide table Id value directly from consuming page and reuse Declarative Component in many pages.

Consuming application declares Tag library for Declarative Component - ExportToolbar:

Library is available in Component Palette:

Consuming page structure defines three main elements: data table, panel collection and export toolbar (our Declarative Component):

Here is main question now - how to wire together Export listener from Declarative Component and table in consuming page. The main trick - we should declare complete path and pass it through ExportId attribute. We should specify ExportToolbar Id (et1), enter into this component, and reference Panel Collection (pc1) from there. Finally, we need to access table component (t1) itself. Expression language for this case: #{et1::pc1:t1}:

On runtime we can see Export button from Declarative Component and ADF table with data:

Export works successfully:

Gotchas when using memory scope prefixes in EL to access managed beans

frank.nimphius — Tue, 09 Mar 2010 11:09:52 PST

Interesting post on the Oracle JDeveloper Oracle internal mailing list, answered by Andrew Robinson. Accessing a managed bean in a standard servlet scope like sessionScope or requestScope using the scope as a prefix fails if the bean instance does not exist. Thus, bean reference like #{sessionScope.myBean} may fail while #{myBean} always succeeds. The reason for this is that #{sessionScope….} and #{requestScope…} reference a Map in memory and not the JSF framework.

But why would you want to use the memory scope as a prefix? If you reference an attribute in memory scope, then the search goes from smallest scope to broader scope, which means that if – by accident – there exist two objects with the same name and you wanted to access the object in the broader scope, chances are you access the wrong object. So prefixing the expression puts you on the save side. This however is only good to use when you access objects that already exist in memory (wich could be a previously instantiated managed bean – of course)

Managed beans must be instantiated before they become available in the memory scope, which means they need to be accessed through JSF. Luckily, JSF does not allow to configure two managed beans with the same name in different scopes. So even without a scope prefix, there is no risk that application code accidentally accesses the wrong object.

Note however that using ADFc specific scope like viewScope and pageFlowScope, a prefix of “pageFlowScope” or “viewScope” is required in the EL reference.

Frank

Integration in Oracle ADF with ADF Task Flows and Dynamic Regions Navigation

Andrejus Baranovskis — Tue, 09 Mar 2010 01:59:06 PST

Today one more post from Integration series. There is a case, when Dynamic Region might have navigation to another Dynamic Region. If user will open one region from another, menu selection should be refreshed accordingly. I'm describing how to do this, thanks to blog Reader who asked this question.

Download updated sample - ADFIntegrationRegions3.zip, based on my previous post. Main change comparing to previous post sample - there is ADF Task Flow call from Locations to Departments:

All separate applications are deployed and assembled into one main application, same as it was described before. Only one difference now - first Dynamic Region (Locations) contains Departments buttons, it will navigate to second Dynamic Region (Departments) directly:

User can click on Departments button:

And here we go - Departments Dynamic Region is opened, menu item selection is synchronized as well:

Well, how to implement this? There is a very good hint in Frank Nimphius and Lynn Munsinger book (Building RIAs w/ Oracle ADF) on page #201 RegionNavigationListener. We can declare it for af:region:

And listen for navigation from Locations to Departments, if such navigation happens - we reset menu and switch Dynamic Region (Departments) as current:

Its how it works.

Red Samurai Tool - How To Check ADF 11g Package Structure and ADF Task Flow Parameters

Andrejus Baranovskis — Mon, 08 Mar 2010 10:51:50 PST

In my previous post, I have introduced our JDeveloper 11g extension for ADF code quality validation. I will describe two rules more and will show how you can scan your ADF project for standard guidelines violations. Package structure check and task flow input parameters are documented today.

I'm demonstrating rule execution using updated sample application - RedSamuraiToolTestSample1.zip. Just to remind you, extension can be invoked by right clicking on Model or ViewController project and selecting it from available menu:

I will choose to run Package Structure Check rule:

Several violations are reported for - Application Module, View Link and Association:

Let's double check Model project structure, and we can see that report was correct - we need to fix few things for application package structure:

First, I will refactor Application Module into appmodules package:

If we run same rule again, this time only two violations will be reported - good progress:

We need to complete the rest of refactoring for View Link and Association - whole picture is correct now:

This is confirmed by our extension as well - no more violations for package structure:

Different projects may have different package structure standards, you can customize Red Samurai extension execution through preferences window:

Another rule I will describe - ADF Task Flow parameters naming convention:

Let's assume, we have a standard to give in prefix for ADF Task Flows parameter names. Developer forgot this standard and gave incorrect name - myParameter:

We run our rule to scan for ADF Task Flow input parameters names:

And here we go - rule violation is reported:

When parameter name is fixed to be inLastName:

No more violations for this rule are reported:

How-to protect your ADF pages

frank.nimphius — Mon, 08 Mar 2010 07:19:56 PST

A great discussion on the JDeveloper forum on OTN brough a new addition to ADF application security that I like to share.

Chapter 30 of the Oracle® Fusion Middleware Fusion Developer’s Guide for Oracle Application Development Framework 11g Release 1 explains the JAAS protection mechanism for ADF pages and Task Flows. In here it is recommended that you reduce the number of JSF pages in the adfc-config.xml file to the absolute minimum and only give ADF Security permissions to those documents that need to be accessible from a browser request.

All other pages should be located in bounded task flows, which you can protect declaratively against GET requests, as they are issued from a browser URL. Bounded task flows need to be ganted to users through application roles to be accessible.

The discussion on OTN is about protecting the phyical JSPX files. If you are an authenticated and authorized user, then you could directly access the JSPX page, e.g. calling localhost:7101/myapp/faces/Departments.jspx. This then serves the page – though it may not be fully functional because it is not launched within the controller context.

The recommendation therefore is to store JSPX documents under the WEB-INF directory of the public_html folder. This solves the problem of users accessing physical files directly

Frank

Ps.: Note that if moving JSPX documents into the WEB-INF folder is not an option for you, you can write a servlet filter that checks the incoming request URL for the resource it accesses. If a jspx file is accessed you would return a http 403 error.

JDev 11gPS1 – Java editor "Declaration Insight"

noreply@blogger.com (Chris Muir) — Sun, 07 Mar 2010 03:54:00 PST

The JDev11gPS1 New Features page lists a large amount of improvements, including something called the "Declaration Insight". The New Features blurb lists this feature as "When declaring local variables from method calls, declaration insight can automatically add the declaration and assignment code as well as completing the method call."

Like us, if you're using JDev11gPS1 you've probably already stumbled upon this feature and not realized it.

You'll be familiar with the traditional Completion Insight. Say in an EntityImpl you're implementing a method and within you want to call the super class method to get the database transaction. However you've forgotten the function name, is it getDBTransaction or getDatabaseTransaction? This is easily solvable by starting to type the function name "getD" then activating Completion Insight, either via pressing Ctrl-Space or the Source menu's same named option. The editor will show the Completion Insight popup in blue with all the functions starting with "getD" in the super class stack, including the method we’re interested in getDBTransaction:

Selecting the same named method, the method is instantly copied into the code:

...saving you some typing and hunting around for the right method.

However the Completion Insight only really gives the right hand side of the assignment expression. It would be good if you could get the IDE to create the left hand side of the assignment expression creating a variable of the correct type to take the result from the function, as well as the function call on the right hand side of the assignment operator as per what the Completion Insight does.

This is where the new "Declaration Insight" comes in. On invoking the Completion Insight with Ctrl-Space showing itself in blue, if you press Ctrl-Space again you'll see the popup changes to puce and displays the very similar Declaration Insight:

Again selecting the same named method, using the Declaration Insight the result is:

....where both the function call and the variable to be assigned the result are inserted into your code, ultimately saving you a bit more typing. If you're like me, and always forgetting what the return type is by the time you're back to the editor, and having to hunt for it again by double invoking the Completion Insight, this will same some extra time.

A minor but useful enhancement in the latest JDev11gPS1 release.

Demo of Apache MyFaces 2 and OpenWebBeans

matthiaswessendorf — Sat, 06 Mar 2010 05:28:42 PST

Recently the Apache MyFaces project released its second beta release and yesterday the Apache OpenWebBeans project released its M4 release.

These are great milestones in the direction of JavaEE at Apache!

A few month ago Bernd Bohmann and I were giving a JSF2 + X presentation in Muenster, at the JUG. The presentation was great and we showed a lot of cool features of JSF2 and CDI. The big plus was that we were Apache projects (MyFaces and OWB), which we build from the trunk. Now since there are these important milestones, I was able to actually make the demo project available under my “facesgoodies” demo/kickstart project.

Get the source of the Maven project from here.

Once you extracted the source, just run “mvn” and Maven downloads all you need!

Enjoy!

Using Struts with JDeveloper 11g?

(author unknown) — Fri, 05 Mar 2010 07:17:50 PST

If you are, then you need to view and respond to this announcement which I've posted on the OTN discussion forum...

Red Samurai Tool - JDeveloper 11g Extension to Validate ADF Code Quality

Andrejus Baranovskis — Sun, 07 Mar 2010 03:44:26 PST

I was working long on JDeveloper 11g extension for ADF 11g code quality checks. Finally it is available for public use - first release. This release is based on my Oracle Forms to Oracle Fusion 11g migration experience.

You can download extension - redsamuraiqt_1_0.zip and install it through JDeveloper Update wizard. It is available directly from Oracle JDeveloper Open Source and Partners Extension update center as well. Additionally, you can download sample project I'm using for this post - RedSamuraiToolTestSample.zip.

When you will run it, first screen will be welcome screen:

Next, you will be given with a list of rules to be applied for ADF code quality validation:

And finally, we have confirmation screen:

Extension can be customized through JDeveloper Preferences wizard:

You can install redsamuraiqt_1_0.zip extension through JDeveloper Check for Updates wizard from local file:

Or simply to download it from Open Source and Partner Extensions update center:

In order to invoke Red Samurai tool, right click on Model or ViewController project and select RedSamurai QT option:

To demonstrate extension functionality, I decided to show how you can ensure all View Objects contain ORDER BY clause:

It will report rule violations - View Object name and rule title:

Then you go to View Object screen and add ORDER BY clause:

If same rule is applied again, no more violations will be reported:

Another example - page title. We may have a rule to ensure all page titles are coming from Message Bundle file. If developer forgot to use title from Message Bundle and typed hard coded value:

Let's run Page Document Title rule:

Tool will generate report document, where violation will be reported:

It says that page title must be used from Message Bundle and property key should have specific value. I correct this violation and map page title to Message Bundle entry:

You can check, Message Bundle reference should be included:

Run same rule again, no violations now:

Check for my next blog posts on the same topic - I will post updates and extension improvements.

Ning’s Async Http Client and Twitter Streaming API

matthiaswessendorf — Fri, 05 Mar 2010 04:25:33 PST

Recently I played with the Apache Wink REST Client to access the Twitter Streaming API. Yesterday Jean-Francois Arcand announced the availability of Ning’s new Async Http Client. The blog looked interesting and the Twitter stream is a perfect example to combine the two. If you are behind a firewall you need to set a proxy-server on the AsyncHttpClientConfig and pass it into the constructor of the AsyncHttpClient. After that, you simply call the prepareGet(…) and here you pass in an anonymous AsyncCompletionHandler:

String logon = "user:password";
String encodedLogon = new BASE64Encoder().encode(logon.getBytes());

AsyncHttpClientConfig cc = new AsyncHttpClientConfig.Builder()
 .setProxyServer(
 new ProxyServer(Protocol.HTTP, "my-proxy", 8080)
 )
 .build();

AsyncHttpClient asyncHttpClient = new AsyncHttpClient(cc);

try
{
 Future<Response> f = asyncHttpClient.prepareGet(
 "http://stream.twitter.com/spritzer.json")
 .addHeader("Authorization","Basic " + encodedLogon)
 .execute(new AsyncCompletionHandler()
 {
 @Override
 public STATE onBodyPartReceived(HttpResponseBodyPart content)
 throws Exception
 {
 System.out.println("Tweet: " + new String(content.getBodyPartBytes()));

 return STATE.CONTINUE;
 }
 @Override
 public Object onCompleted(Response response) throws Exception
 {
 // TODO Auto-generated method stub
 return response;
 }
 @Override
 public void onThrowable(Throwable arg0)
 {
 }
 });

 Response r = f.get();
....

The interesting part of the anonymous implementation is its onBodyPartReceived(). Once the Twitter server has put a new tweet into the stream, the callback is called as soon as the actual (JSON) output arrives your client machine. In here, you could parse the JSON can trigger different methods of your application, based on what you want.

The AsyncHttpClient is pretty interesting – However I noticed a limitation that no parameters are allowed on GET request. Not via its setParameter/s() method nor via using the ? character => http://server_url?param=value.

Need to check more by checking out the code from here.

Parameters with HTTP POST

Of course, doing a HTTP_POST the parameters work as expected

Request req = new
 RequestBuilder(RequestType.POST)
 .setUrl("http://stream.twitter.com/1/statuses/filter.json")
 .addHeader(
   "Content-Type","application/x-www-form-urlencoded")
 .addHeader("Authorization","Basic" + encodedLogon)
 .setParameter("track", "Java")
 .build();

 Future<Response> f = asyncHttpClient.executeRequest(req,
  new AsyncCompletionHandler()
 {
 ....
 // similar as above...
 }
...

Looking forward to continue using this neat project! Good job guys…

The Poetry of Wisdom in Oracle Documentation: E.g. PPR and List Of Values

frank.nimphius — Fri, 05 Mar 2010 02:48:03 PST

Our ADF Faces documentation contains little nuggets of poetry and wisdom that are easy to memorize helping you to better understand the product – and answer questions on OTN with it. For example, today I found and liked:

Note: If your trigger component is an inputLov or an inputComboBoxLov, and the target component is an input component set to required, then a validation error will be thrown for the input component when the LOV popup is displayed. To avoid this, you must use programmatic partial page rendering.

Note: In some cases, you may want a component to be rerendered only when a particular event is fired, not for every event associated with the trigger component, or you may want some logic to determine whether a component is to be rerendered. In these cases, you can programatically enable PPR.

Excellent !

Frank

Want to dig your own nuggets? here is the documentation: Looking forward to read your blogs and tweets with your favorite quotes.

Java Memory Management

Gert Leenders — Thu, 04 Mar 2010 12:13:08 PST

When writing programs it’s always good to know what’s happing in the core of the Framework you’re using. This allow you to get a better idea why things happen in a certain way or what to do in case you receive an error.

So if you’re a java programmer a good thing to read is this paper on memory management in the Virtual machine. It has a short introduction, a brief overview of the concepts and later on it dives a little deeper with an overview on the different garbage collectors and a chapter on ergonomics. At the end you get some tips and recommendations.

Chapter 6 also contains the paragraph ‘What to Do about OutOfMemoryError’ helpful for us all I think :-) (especially when you’ve ever have used BufferedImage)

Here you can find more information on Java HotSpot Garbage Collection.

Patch for SQL Developer 2.1 released

Olivier Dupont — Wed, 03 Mar 2010 06:23:41 PST

Just noticed that a patch is released for SQL Developer 2.1. From the Oracle website:

Oracle SQL Developer 2.1.1 is a patch release to SQL Developer 2.1, which was released in December 2009. This patch release resolves a number of the issues raised and addresses a few additional feature requests raised on the SQL Developer Exchange.

You can download it here.

SQL Developer and ApEx: Application missing

Olivier Dupont — Wed, 03 Mar 2010 06:14:54 PST

Last week I was searching for a long time to find my application in SQL Developer. I wanted to deploy it to a production environment, the application had APP_ID 113 but I couldn’t find it in SQL Developer:

After some time I noticed an other application that had the same name: “Daily Report”. After I changed the name of my application to “Daily Reports”, I could see it in SQL Developer and deploy it!

Normal comment service is now resumed

Gerard Davison — Tue, 02 Mar 2010 08:51:48 PST

I have been fairly remiss in responding to comments, I have just worked my way though the backlog and now up to date. yay

Building and testing Jersey

Gerard Davison — Tue, 02 Mar 2010 05:01:32 PST

So I was playing with a patch Building an testing to Jersey but I was having trouble building and running the tests. It seems that there are problems if you don't have the same specific version of Maven, (2.0.9), once that is solved you might run across another issue as the default memory given to Maven will not be enough for all the test to succeed.

The way to track the correct values is to take a look at "hudson/jersey.sh" and this will set the MAVEN_OPTS to:

export MAVEN_OPTS="-Xms512m -Xmx1024m -XX:PermSize=256m -XX:MaxPermSize=512m"

This it turns out isn't sufficient if you are running behind a firewall, at least on Linux, and you need to specify the web proxy as well for some tests:

export MAVEN_OPTS="-Xms512m -Xmx1024m -XX:PermSize=256m -XX:MaxPermSize=512m -Dhttp.proxyHost=proxy -Dhttp.noProxyHosts=localhost"

With that resolved I can build and test all of Jersey in a relatively small amount of time. Although it does seem you need an active network connection which is a shame.

Integration in Oracle ADF with ADF Task Flows and Dynamic Regions Pending Changes

Andrejus Baranovskis — Mon, 01 Mar 2010 11:33:48 PST

From my previous post - Integration in Oracle ADF with ADF Task Flows and Dynamic Regions, you can learn how to integrate separate Oracle ADF applications using dynamic regions. I'm sure, you will want to prevent user navigation from one region to another, when there are unsaved pending changes available. Its pretty simple in ADF 11g, I will describe today.

I have updated sample application from my previous post, download updated archive - ADFIntegrationRegions2.zip.

So, how to prevent user navigation if there are unsaved changes? Key thing - from main application we can see Data Controls of imported applications. Even when main application Model project doesn't contain any ADF BC, still we can see Data Controls from imported ADF libraries:

And that is great, because we can access Data Control and check it for any existing uncommitted data.

I have implemented pending changes check inside Managed Bean, where Dynamic Regions are activated. In case of unsaved data, user is prevented from navigation and forced to stay in current region:

Pending changes are validated simply by accessing Data Control transaction and checking if it is dirty:

If there will be no pending changes, next dynamic region will be opened:

But, if user will type data and without saving will try to open another dynamic region, system will prevent him and inform about unsaved data:

Same rule works with form component:

The Obligatory Calculator in JSF 2.0

Buttso — Sun, 28 Feb 2010 19:32:48 PST

Checked out some of the high level JSF 2.0 new features recently using NetBeans 6.8 and GlassFish v3. For what it's worth, I think they are very usable, feature rich and effcient pairing for conducting Java EE 6 development.

As with all old habits, some won't die. And my habit for taking a quick look at any new programming language/framework is to build a very simple calculator with one screen and some simple calculation logic.

With NetBeans, creating a new Web project is trivial. To add JSF support select it as a framework to use.

After a bit of navel gazing, I realized a significant part of the unholy dislike I had for JSF 1.2 and its earlier versions predominantly stemmed from the need to live in the configuration red zone -- faces-config.xml. Every damned thing that you wanted to use or access pretty much needed to be defined in the configuration file: managed beans definitions with packages/classes and names and scopes, even the most simples of page navigation paths, etc.

But as of JSF 2.0, that has mostly changed! Accomodating a convention over configuration model for page navigation and making use of annotations for declaring managed bean components (and associated runtime attributes and property values) in my simple example, I didn't have to even look at the faces-config.xml file. Happy Days.

Here's my simple CalculatorManagedBean, which is responsible for performing the arduous task of calculating a result from a given two values and an operand. It also supplies the operand values for the screen to display.

To declare this as a ManagedBean, all I had to do was to add the @ManagedBean annotation. I also decided to bind this ManagedBean into each clients HttpSession so it was created once, and was able to store property values set from eacg clients page.

 1 package sab.demo.calc.beans;
 2 
 3 import java.io.Serializable;
 4 import javax.annotation.PostConstruct;
 5 import javax.faces.bean.ManagedBean;
 6 import javax.faces.bean.SessionScoped;
 7 
 8 @ManagedBean(eager=true)
 9 @SessionScoped
10 public class CalculatorManagedBean implements Serializable {
11 
12     public static char[] operands = { '+', '-', '*', '/' };
13 
14     int value1;
15     int value2;
16     char operand;
17     String result;
18 
19     public CalculatorManagedBean() {
20     }
21 
22     public char[] getOperands() {
23         return operands;
24     }
25     
26     public char getOperand() {
27         return operand;
28     }
29 
30     public void setOperand(char operand) {
31         System.out.printf("setOperand: %s", operand);
32         this.operand = operand;
33     }
34 
35     public String getResult() {
36         return result;
37     }
38 
39     public void setResult(String result) {
40         this.result = result;
41     }
42 
43     public int getValue1() {
44         return value1;
45     }
46 
47     public void setValue1(int value1) {
48         System.out.printf("setValue1: %s\n", value1);
49         this.value1 = value1;
50     }
51 
52     public int getValue2() {
53         return value2;
54     }
55 
56     public void setValue2(int value2) {
57         System.out.printf("setValue2: %s\n", value2);
58         this.value2 = value2;
59     }
60 
61     public void calculate() {
62         switch(getOperand()) {
63             case '+' :
64                 result = String.valueOf(value1 + value2);
65                 break;
66             case '-' :
67                 result = String.valueOf(value1 - value2);
68                 break;
69             case '*' :
70                 result = String.valueOf(value1 * value2);
71                 break;
72             case '/' :
73                 double v1 = value1;
74                 double v2 = value2;
75                 result = String.valueOf(v1 / v2);
76                 break;
77         }
78         System.out.printf("Calculate: %s %s %s = %s\n",
79                 getValue1(),
80                 getOperand(),
81                 getValue2(),
82                 getResult());
83 
84     }
85 
86     @PostConstruct
87     public void postConstruct() {
88         System.out.println("postConstruct");
89         operand = '+';
90         value1 = 0;
91         value2 = 0;
92         result = "n/a";
93     }
94 }
95 
96

With the ManagedBean taken care of, the next step was to create the JSF page. With JSF 2.0, it now uses Facelets as the default view technology instead of JSP. This means there are lots of things that are able to be expressed more naturally in the view layer, which were previously difficult or cumbersome in the older JSP model.

A really useful thing I found in facelets was the ability to render a ManagedBean property directly in the page, without needing to surround it with other tag library calls.

So to create my calculator screen, I simply added a couple of fields, and wired them into the CalculatorManagedBean that I'd developed. Again, following convention over configuration, the default name for a ManagedBean is a lower case version of the classname, which makes them easy to remember/lookup from a project hierachy (as opposed to hunting through XML). Of course NetBeans makes this easy since it has code-insight which presents the names of known ManagedBeans and their available properties for insertion via a few keystrokes.

The list of operands values shown in the select list are populated from a property on the ManagedBean which returns an array of char.

The "=" button is wired into the calculate operation, which takes its current property values, performs the desired operation and sets the result property, which is then displayed in the result field on the page.

 1 <?xml version='1.0' encoding='UTF-8' ?>
 2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 3 <html xmlns="http://www.w3.org/1999/xhtml"
 4       xmlns:f="http://java.sun.com/jsf/core"
 5       xmlns:h="http://java.sun.com/jsf/html">
 6     <h:head>
 7         <title>Calculator Facelet</title>
 8     </h:head>
 9     <h:body>
10         <h:column><h3 style="font-family: arial; font-variant: small-caps; color: #336699">Calculator</h3></h:column>
11         <h:form>
12             <h:panelGrid columns="1" style="text-align: center; border: 1px solid #336699; padding: 5px; ">
13             <h:column>
14                 <h:inputText id="value1" value="#{calculatorManagedBean.value1}" 
15                              size="5" maxlength="5" style="text-align: right;"/>
16             </h:column>
17             <h:column>
18                 <h:inputText id="value2" value="#{calculatorManagedBean.value2}" 
19                              size="5" maxlength="5" style="text-align: right"/>
20             </h:column>
21             <h:panelGrid columns="2">
22                 <h:column >
23                     <h:selectOneMenu id="operand" value="#{calculatorManagedBean.operand}" 
24                                      style="text-align: center;">
25                         <f:selectItems value="#{calculatorManagedBean.operands}"/>
26                     </h:selectOneMenu>
27                 </h:column>
28                 <h:column><h:commandButton value="=" action="#{calculatorManagedBean.calculate}"/></h:column>
29             </h:panelGrid>
30             <h:column>
31                 <h:inputText id="result" value="#{calculatorManagedBean.result}" 
32                              readonly="true" size="5" style="font-weight: bold; text-align: right"/>
33             </h:column>
34         </h:panelGrid>
35         </h:form>
36     </h:body>
37 </html>
38 
39 
40

Put it all together and run using the local GlassFish instance, the page works and looks like this.

So there it is, a JSF 2.0 version of my old habit up and running in a few minutes. I like what I've seen with JSF 2.0 so far.

Of course, the use of @ManagedBean annotation in JSF 2.0 may be dead already with the arrival of CDI in Java EE 6 and its @Named annotation, but that's not an issue I'm going to explore here.