5th 0 certification validates the ability of applications using Java 2 SE 5 design. 0 technology. Passing this test is essential for you when you get to the Sun Certified Developer for Java 2 Platform (sCJD), Sun Certified Web Component Developer for the J2EE Platform (SCWCD), Sun Certified Business Component Developer (SCBCD), Sun Certified Mobile Application to Developer (SCMAD), Oracle Certified Solution Developer and Oracle Certified Enterprise Developer programs, and Master CIW Enterprise Developer certification. SCJP 5th 0 certification requirements can be a trial

i. e. CX-310 must pass to reach 055, the fifth SCJP 0 certification. Although there are no prerequisites for this certification, it would be helpful if the hands on experience with the basic syntax of the Java programming language. Benefits of SCJP Certification SCJP certification proves your expertise on the Sun Java products and technologies. Experts hold the SCJP certification are preferred by employers, and they also get preference in promotions. want to SCJP certification is helpful for professionals to update their credentials and get recognition from the industry. SCJP Certified professional can find appropriate jobs and simply paid more.

Lets discuss how to prepare for him.

Preparation: This is the most important phase of the SCJP. First you need to brush up all your foundation fundamentals in Core Java. You can

following books on this: for Java 5 Study Guide (Exam 310-055) by Katherine Sierra There are many other renew book on Java-based but I would say use as much Java knowledge is enough to clear the sample. Especially book by Katherine Sierra is very important to score more marks in SCJP. You should study all the chapters thoroughly and try to complete all writing questions given at the end. If you give any problem in this paper question the face, should be the end of each chapter, go back and read again the chapter.
The complete reference is a good book for any requested concept that you missed or can not find in the other book.

Test Simulator: Here comes the second part, on completion of these two books you need to prepare for the test simulator. This is a very important step because it determines how much you learn and see if you ready for the test or not. After basic in Core Java, you should know where you stand. Test simulator will help you to determine whether to go the right time, in which chapter or topic you are poor and can then go back and help prepare again.
There's much simulator on the market, I personally recommend you uCertify Test simulator for SCJP. This is an excellent tool that I found and it helped me a lot in dealing with difficult topics such as generics and collection. Upon completion of the books that I did not know, which is a part of my preparation to be weak and needs improving. I went to test for uCertify, noting that issues such as generics and collection, I am with fewer brands. I went back to book and relate this topic again, and guess what, I better mark in my final exam in generics and collection.
Thanks uCertify.

Lets discuss uCertify.

1 UCertify PrepKit tour of features:

PrepKit CX310-055, Java 5 0 an interactive software that helps you is to learn, tracks your progress identifies areas for improvements and simulates the actual exam. This PrepKit contains 7 interactive practice tests with over 801 challenging questions guaranteed comprehensively cover all the objectives for the CX310-055: exam. With detailed analysis for each question, over 249 study notes, interactive quizzes, tips and technical articles, this PrepKit ensures that you know a solid understanding of basic technical concepts to ace your certification exam.
I like best is 100% money-back guarantee, if you do not get certified on the first try is, they become your money back.

This is the first screen will prompt you for the purchase and installation, you can find it on your PC.

7, section practice test will each have 75 questions. They also have diagnostic test of 15 questions, except that it will be a final test with 40 questions. The best part I liked was in the form of 236 question quiz. They also have opportunity to custom tests that you can choose your topic and the number of those, you have a really nice option to the topic
work

where you feel you are not strong and need to work on!

On the right you will find tips and tricks, which turned out to be very helpful SCJP for me was:

The complete simulator costs $ 74. 98, I think, worth an investment, as it related to your career and also in comparison to the functions and importance of this test, it is worth money in this.
a trial version available, you can use to assess their significance, but the purchase is a nice option, since it can offer more and take control of your exam. Below is the difference between trial and final version, as in the website or book.
Full length interactive tests tricky 1 7 questions with full explaination (inc. Quiz) 15
801 Articles, How Tos. . , Tips Study Notes 40 249 Detailed reports and analysis tools, no time limit, no registration No adware, malware or spyware 24×7 Unlimited upgrade up to 1 year unconditional 100% Money-back guarantee 2 How to use uCertify PrepKit effective:

To start most from uCertify always there after the primary, as I mentioned the books already. Jump directly to non-Simulator. The best way is to first study how Exam tips WECK, study notes, articles and advice. Then for interactive quiz go as they always renew your preparation and get some confidence, if you studied well. Then go for the practice test and weak themes of preparation, a practice test can also help you in this.

3 What contributed to my success uCertify:

As I discussed earlier is also the biggest advantage I have received from uCertify, I arrived at my weakest subjects know i. e, Generics and Collection , then I worked on these issues and most problems can be solved on the basis of this. And it has to do me a few days. The tips and materials have helped me a lot to work on final touches to the test. Flash card has helped me, more important point at the last save. Beg best part was personal test by which I include only focus primarily on tests of generics, collection, and concurrency.

4 My experience with uCertify PrepKit:

After completing my foundation books by Katherine Sieera, I was for some good test simulator, I can try search. I have a preliminary test simulator, which I really did not like, then told my Firend uCertify me and believe me after the purchase I was very confident. During the test, after half a question I knew I was clear. And all the trust was of my favorite test simulator uCertify. I was afraid before the test because I thought that I might not, but after trying this simulator I was confident.
Now I'm next after SCJP SCWCD and I already grabbed a copy of uCertify SCWCD simulator to test and would be held soon.

Final Touch for Exam: Once your base and simulator will be ready on you will be for the test. just follow these simple tricks just before the test: Book your place and time for the test even before advance. She hunts for them. It is always advisable to test, taking in the morning, you will be fresh not working, studying hard, or just before a night given its more important point in the simulator, just before to revise a day of the test during test test do not panic and always try simple question first special care with matching type of question, as if you try this question again open the previous answer is deleted and you have once again to this question you try drinking water before the test

instead of buy this, try one or two books, and you will be impressed by the amount of information can be found on the Domain. This is the easiest way to access tons of Java tutorials or a lot of very useful Java tips with no effort and no cost at all.

The Java programming language and platform have been initiated during the early nineties and developed a few years later she was re-designed for use on the Internet, and since then his popularity has increased greatly, especially on the server side of the Internet.
Today, a number of Java experts and a lot of documentation has been written on this topic, so if you are a beginner searching for Java tutorials to learn more, and if you is an advanced user, you can always use the large number of Java tips, which are found and can help you solve almost any problem do you encounter on your way to the perfect Java programs.


. You can do everything from "Getting Started", the fundamentals of the Java language, essential classes, which are more specialized tutorials such as security in Java, graphics, working with databases and much more. Here you will find websites that give tips in Java and Java tutorials for those who need specialized. Those written tutorials and tips from experts and are grouped into categories that you immediately see the Java or Java-Tutorials Tips you seek help. The best thing is learning to read more Java tutorials, and the Java tutorial, you learn from the short and useful tips you can combine Java.

On the other hand, if you are an experienced programmer and you want to share your knowledge, you can start writing Java Java tutorials and tips to help the newcomers, and others who need it.
When writing Java tutorials make sure you make are clear and understandable and that you report on all aspects of the problem.
Even when writing Java-Tips if you want to find people easily understand the information you provide there are some "rules" should respect the way the selection of the best titles of the Java tip covered exactly what you are presenting, and the best subtitle of the course, the title must expand a bit, you can also write a short summary or comment if you know where you do your Java tips, then do you want to describe in the introduction, the command list, the statements in it and a little conclusion if you wish. You can even include a link to more detailed Java tutorials on this topic.

Java Java tutorials and tips are the best resource for learning and improvement in Java, so you start searching for them, or start writing one if you are experienced and share want!

Re: Extract File from Java Sony Ericsson K850
Yes, you can extract the Java file from Sony Ericsson K850 using the Uploader for the A2-A2 (K850, C902, C905, etc), free working tool. So you must download it first and then you can use it, unpack your Java files from the installation directory. So, use this tool and get theGoogle Map Java file for your future use. You can use this tool on the Internet that is free. But, you download it from trusted sites. How to extract Java file from Sony Ericsson K850?

Re: Extract File from Java Sony Ericsson K850
Hi, you can use Google Maps Java extract from your Sony Ericsson K850 with the use of a few tricks file. You need to use the Explorer for getting the system files. Then you search the hidden files and then use the hidden files for the user JAR file that theGoogle related card. If you save this jar file that only the directory you want. And you continue to use the JAR file when you need it.

Re: Extract File from Java Sony Ericsson K850
I do not think that it not be a solution for this. You need to select re-download the same file from the Internet and save it for when the option or how to install them, then Save option and you can ask for the setup file for your particular application. Then you can use the specific file, run if you want. So, there is no other way than downloading the same file to save again, but the choice of the option. Make sure that you save in a position to file that is not under the JAR file extension of the jad extension.

We will cover the following topics in more detail:

• What is JSF and how to install it on JBoss AS
• How to create a JSF facade for our pasture application
• How to configure JBoss Web Server

Wonder what was the first message sent through Internet? At 22:30 hours on October 29, 1969, a message was transmitted using ARPANET (the predecessor of the global Internet) on a host-to-host connection. It was meant to transmit "login". However, it transmitted just "lo" and crashed.

Developing web layout

The basic component of any Java web application is the servlet. Born in the middle of the 90s, servlets quickly gained success against their competitors, the CGI scripts. This was because of some innovative features, especially the ability to execute requests concurrently, without the overhead of creating a new process for each request. However, a few things were missing, for example, the servlet API did not address any APIs specifically for creating the client GUI. This resulted in multiple ways of creating the presentation tier, generally with tag libraries that differed from job to job and from individual developers.

The second thing that was missing in the servlet specification was a clear distinction between the presentation tier and the backend. A plethora of web frameworks tried to fill this gap; particularly the Struts framework effectively realized a clean separation of the model (application logic that interacts with a database) from the view (HTML pages presented to the client) and the controller (instance that passes information between view and model).

However, the limitation of these frameworks was that even if they realized a complete modular abstraction, they still failed as they always exposed theHttpServletRequest and HttpServletSessionobjects to their action(s). Their actions, in turn, needed to accept the interface contracts such as ActionForm, ActionMapping, and so on.

The JavaServer Faces that emerged on the stage a few years later pursued a different approach. Unlike request-driven Model–View–Controller (MVC) web frameworks, JSF chose a component-based approach that ties the user interface component to a well-defined request processing lifecycle. This greatly simplifies the development of web applications.

The JSF specification allows you to have presentation components be POJOs. This creates a cleaner separation from the servlet layer and makes it easier to do testing by not requiring the POJOs to be dependent on the servlet classes.

In the following sections, we will describe how to create a web layout for our application store using the JSF technology. For an exhaustive explanation of the JSF framework, we suggest you to surf the JSF homepage at http://java.sun.com/javaee/javaserverfaces/.

Installing JSF on JBoss AS

JBoss AS already ships with the JSF libraries, so the good news is that you don't need to download or install them in the application server. There are different implementations of the JSF libraries. Earlier JBoss releases adopted the Apache MyFaces library. JBoss AS 4.2 and 5.x ship with the Common Development and Distribution License (CDDL) implementation (now called "Project Mojarra") of the JSF 1.2 specification that is available from the java.net open source community.

Switching to another JSF implementation is anyway possible. All you have to do is package your JSF libraries with your web application and configure your web.xml to ignore the JBoss built-in implementation:

<context-param>
<param-name>org.jboss.jbossfaces.WAR_BUNDLES_JSF_
IMPL</param-name>
<param-value>true</param-value>
</context-param>

We will start by creating a new JSF project. From the File menu, select New | Other | JBoss Tools Web | JSF | JSF Web project. The JSF applet wizard will display, requesting the Project Name, the JSF Environment, and the default starting Template.

Choose AppStoreWeb as the project name, and check that the JSF Environment used is JSF 1.2. You can leave all other options to the defaults and click Finish. Eclipse will now suggest that you switch to the Web Projects view that logically assembles all JSF components. (It seems that the current release of the plugin doesn't understand your choice, so you have to manually click on the Web Projects tab.)

The key configuration file of a JSF application is faces-config.xml contained in the Configuration folder. Here you declare all navigation rules of the application and the JSF managed beans. Managed beans are simple POJOs that provide the logic for initializing and controlling JSF components, and for managing data across page requests, user sessions, or the application as a whole.

Adding JSF functionalities also requires adding some information to your web.xml file so that all requests ending with a certain suffix are intercepted by the Faces Servlet. Let's have a look at the web.xml configuration file:

<?xml version="1.0"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

<display-name>AppStoreWeb</display-name>
<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>server</param-value>
</context-param>
<context-param> [1]
<param-name>com.sun.faces.
enableRestoreView11Compatibility</param-name>
<param-value>true</param-value>
</context-param>
<listener>
<listener-class>com.sun.faces.config.
ConfigureListener</listener-class>
</listener>
<!-- Faces Servlet -->
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- Faces Servlet Mapping -->
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>
<login-config>
<auth-method>BASIC</auth-method>
</login-config>
</web-app>

The context-param pointed out here [1] is not added by default when you create a JSF application. However, it needs to be added, else you'll stumble into an annoying ViewExpiredException when your session expires (JSF 1.2).

Setting up navigation rules

In the first step, we will define the navigation rules for our AppStore. A minimalist approach would require a homepage that displays the orders, along with two additional pages for inserting new customers and new orders respectively.

Let's add the following navigation rule to the faces-config.xml:

<faces-config>
<navigation-rule>
<from-view-id>/home.jsp</from-view-id> [1]
<navigation-case>
<from-outcome>newCustomer</from-outcome> [2]
<to-view-id>/newCustomer.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>newOrder</from-outcome> [3]
<to-view-id>/newOrder.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<navigation-rule>
<from-view-id></from-view-id> [4]
<navigation-case>
<from-outcome>home</from-outcome>
<to-view-id>/home.jsp</to-view-id>
</navigation-case>
</navigation-rule>
</faces-config>

In a navigation rule, you can have one from-view-id that is the (optional) starting page, and one or more landing pages that are tagged as to-view-id. The from-outcome determines the navigation flow. Think about this parameter as a Struts forward, that is, instead of embedding the landing page in the JSP/servlet, you'll simply declare a virtual path in your JSF beans.

Therefore, our starting page will be home.jsp [1] that has two possible links—the newCustomer.jsp form [2] and the newOrder.jsp form [3]. At the bottom, there is a navigation rule that is valid across all pages [4]. Every page requesting the home outcome will be redirected to the homepage of the application.

The above JSP will be created in a minute, so don't worry if Eclipse validator complains about the missing pages. This configuration can also be examined from the Diagram tab of your faces-config.xml:

The next piece of code that we will add to the confi guration is the JSF managed bean declaration. You need to declare each bean here that will be referenced by JSF pages. Add the following code snippet at the top of your faces-config.xml (just before navigation rules):

<managed-bean>
<managed-bean-name>manager</managed-bean-name> [1]
<managed-bean-class>
com.packpub.web.StoreManagerJSFBean
</managed-bean-class> [2]
<managed-bean-scope>request</managed-bean-scope> [3]
</managed-bean>

The <managed-bean-name> [1] element will be used by your JSF page to reference your beans. The <managed-bean-class> [2] is obviously the corresponding class. The managed beans can then be stored within the request, session, or application scopes, depending on the value of the <managed-bean-scope> element [3].

Adding a JSF managed bean

The StoreManagerJSFBean class follows the JavaBean patterns, providing get and set methods for its properties (to make the code more maintainable, we have skipped the getter/setter methods that simply wrap the fields of the class). We have declared the bean as request bound, so for each user of the application, JSF creates a StoreManagerJSFBean instance, which is stored within the request scope.

Add to your project a new Java class and name it com.packtpub.web.StoreManagerJSFBean:

package com.packpub.web;
// skipping imports
public class StoreManagerJSFBean {
@EJB(mappedName = "AppStoreEJB/local") [1]
private StoreManager storeManager;
private int customerId;
private int orderQuantity;
private int orderPrice;
private String customerName;
private String customerCountry;
private String orderProduct;
List<Order> listOrders;
List <SelectItem> listCustomers;
public List<SelectItem> getListCustomers() {
if (listCustomers == null) {
listCustomers= new ArrayList();
findAllCustomers();
}
return listCustomers;
}
/*
other getter/setter methods omitted for brevity
*/
public StoreManagerJSFBean() { }
public void findOrders() { [2]
listOrders = storeManager.findAllItems(this.customerId);
}
public void findAllCustomers() {
List<Customer> listCustomersEJB =
storeManager.findAllCustomers();
for(Customer customer:listCustomersEJB) {
listCustomers.add(new
SelectItem(customer.getId(),customer.getName()));
}
}
}
public void saveOrder() {
storeManager.saveOrder(customerId,this.orderPrice,
this.orderQuantity,this.orderProduct);
FacesMessage fm = new FacesMessage("Saved order for
"+this.orderQuantity+ " of "+this.orderProduct);
FacesContext.getCurrentInstance().addMessage("Message", fm);
this.orderPrice=0;
this.orderQuantity=0;
this.orderProduct=null;
}
public void insertCustomer() {
storeManager.createCustomer(this.customerCountry,
this.customerName);
FacesMessage fm = new FacesMessage(«Created Customer
«+this.customerName+ « fromf «+this.customerCountry);
FacesContext.getCurrentInstance().addMessage("Message", fm);
this.customerName=null;
this.customerCountry=null;
// Forces customer reloading
this.listCustomers=null;
}
/* Navigation rules */
public String home() { [4]
return "home";
}
public String newOrder() {
return "newOrder";
}
public String newCustomer() {
return "newCustomer";
}
}

As you can see, the StoreManagerJSFBean references the session bean we have created previously (StoreManager). Therefore, we must tell the compiler how to solve this dependency. This can be easily solved by choosing Properties on the current project, and then choosing Projects from the Java Build Path option. Add the project AppStore to your build path, as shown here:

Having fixed the compilation issues, we can now concentrate on the JSF bean. The first thing we want to capture your attention to is how the StoreManager EJB is injected [1] in the class, skipping completely the lookup/casting/exception handling part.

The findOrders() method [2] retrieves the list of orders from the StoreManager EJB. They will be displayed later in the dataTable component.

The findAllCustomers() [3] is slightly different. It recalls our entity bean's corresponding findAllCustomers() method and then populates a SelectItem object with the list of customers. SelectItem is a JSF object used to render a combobox programmatically. In our case, we will populate it with the customerId (as value) and customerName (as label).

The remaining EJB wrapper methods, saveOrder() and insertCustomer(), are quite intuitive; their job is to persist data for Orders and Customers.

The final piece of code is about navigation rules [4] that are coded as simple Java methods returning the outcome view as a string. For example, in order to return to the homepage from any other page, we will add the following button:

<h:commandButton action="#{manager.home}" value="Back" />

Setting up the view

Setting up the view JSF pages are just behind-the-scenes JSP pages that are engineered by the JSF servlet. Therefore, in order to create your views, add the following pages to your web application: home.jsp, newCustomer.jsp and newOrder.jsp. A new JSP page can be added from the Web Projects menu by right-clicking on the WebContent folder, then choosing New | File | JSP Page and naming it home.jsp.

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%> [1]
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<body>
<f:view> [2]
<style type="text/css"> [3]
@import url("css/appstore.css");
</style>
<h:panelGrid columns="1" border="1" styleClass="spring"> [4]
<f:facet name="header">
<h:outputText value="Order List"/>
</f:facet>
<h:form id="listOrdersForm"> [5]
<h:outputText value="Select Customer:" /> [6]
<h:selectOneMenu id="selectCustomer"
value="#{manager.customerId}" styleClass="buttons"> [7]
<f:selectItems
value="#{manager.listCustomers}" />
</h:selectOneMenu>
<h:commandButton action="#{manager.findOrders}"
value="ListOrders" styleClass="buttons"/> [8]
<h:dataTable value="#{manager.listOrders}" var="orders"
border="1" rowClasses="row1, row2" headerClass="header"> [9]
<h:column>
<f:facet name="header">
<h:outputText value="Product" />
</f:facet>
<h:outputText value="#{orders.product}" />
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Price" />
</f:facet>
<h:outputText value="#{orders.price}" />
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Quantity" />
</f:facet>
<h:outputText value="#{orders.quantity}" />
</h:column>
</h:dataTable>
<h:commandButton action="#{manager.newCustomer}"
value="Insert Customer" styleClass="buttons" /> [10]
<h:commandButton action="#{manager.newOrder}"
value="Insert Order" styleClass="buttons" /> [11]
</h:form>
</h:panelGrid>
</f:view>
</body>
</html>

JSF contains two tag libraries [1] called JSF core and HTML Basic. The former provides a few general tags and some other tags that let you register validators and event listeners to UI components. The latter contains JSP tags that render HTML UI components such as buttons, text fields, checkboxes, lists, and so on. The standard prefixes of these two tag libraries are h and f, and they are declared at the beginning of home.jsp.

The view tag [2] is the container for all JavaServer Faces component tags used on a page. Stylesheets [3] are used here to decorate the UI components. The panelGrid [4] component simplifies the task of constructing a layout table, to hold form fields, labels, and buttons. In this case, it will contain the main input form.

The form element [5] manages an HTML form just the same way as standard form HTML. Rendering simple text on the page can be achieved with an outputText tag [6]. Here, you can use value-binding expressions from your JSF beans.

The selectOneMenu element [7] is used to display an HTML combobox that is bound to a bean collection. Review the findAllCustomers() method of your StoreManagerJSFBean, where the combobox is built dynamically.

The commandButton [8] is applied to render an HTML button. In our case, we have bound the button to the findOrders() method of our JSF bean.

A core JSF tag is the dataTable tag [9] that can be used to render an HTML table using a collection from the backing bean. This component is generally used to display tabular data and it offers a vast choice of built-in options for customizing its header and footer, and for paginating the table.

The last two buttons, [10] and [11], plot the route to the newCustomer and newOrder forms.

The form for inserting a new customer is as follows:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<body>
<f:view>
<style type="text/css">
@import url("css/appstore.css");
</style>
<h:form id="newCustomer">
<h:panelGrid columns="2" border="1" styleClass="spring">
<f:facet name="header">
<h:outputText value="Insert new Customer" />
</f:facet>
<h:outputText value="Name" />
<h:inputText value="#{manager.customerName}" /> [1]
<h:outputText value="Country" />
<h:inputText value="#{manager.customerCountry}" />
<h:commandButton action="#{manager.insertCustomer}" [2]
value="Insert Customer" />
<h:commandButton action="#{manager.home}" value="Back" />
</h:panelGrid>
<h:messages />
</h:form>
</f:view>
</body>
</html>

The inputText fields [1] are used to populate the individual managed bean properties. With the commandButton [2], the insertCustomer() action is recalled, thus inserting a new customer. This is the last JSP needed for our example newOrder.jsp:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<body>
<f:view>
<style type="text/css">
@import url("css/appstore.css");
</style>
<h:form id="newOrder">
<h:panelGrid columns="2" border="1" styleClass="spring">
<f:facet name="header">
<h:outputText value="Insert new Order" />
</f:facet>
<h:outputText value="Product" />
<h:inputText value="#{manager.orderProduct}" />
<h:outputText value="Quantity" />
<h:inputText value="#{manager.orderQuantity}" />
<h:outputText value="Price" />
<h:inputText value="#{manager.orderPrice}" />
<h:outputText value="Customer" />
<h:selectOneMenu id="selectCustomerforOrder"
value="#{manager.customer}">
<f:selectItems value="#{manager.listCustomers}" />
</h:selectOneMenu>
<h:commandButton action="#{manager.saveOrder}"
value="Save Order" />
<h:commandButton action="#{manager.home}" value="Back" />
</h:panelGrid>
<h:messages />
</h:form>
</f:view>
</body>
</html>

Assembling and deploying the application

So far, you have got two standalone projects, one EJB project and one web project. While you could technically deploy them separately, it is worth combining them in an Enterprise ARchive (EAR). The most obvious reason for deploying the application as an Enterprise ARchive is that the web application will be loaded by a ClassLoader in the same hierarchy as the EJB classloader. In short, you don't need to provide the EJB interfaces to the web application, as you would for a standalone application.

Packaging the application can be done entirely by Eclipse, without messing with archive files. From the menu, select New | Other | Java EE | Enterprise Application project. The next facet will request the Project name and a few details about the configuration. Your archive name will be, by default, the project name plus the extension .ear. Verify that both Target Runtime and the Configuration point correctly to the JBoss 5.0 environment.

Click Next. On the window that follows, you can select the components of your archive application, that is, the AppStore application and the AppStoreWeb component. Check the option Generate Deployment Descriptor.

Verify that META-INF/application.xml deployment descriptors contain both the modules enlisted below:

<application>
<display-name>EnterpriseStore</display-name>
<module>
<web>
<web-uri>AppStoreWeb.war</web-uri>
<context-root>AppStoreWeb</context-root>
</web>
</module>
<module>
<ejb>AppStore.jar</ejb>
</module>
</application>

Okay, now you need only a few more laps to complete the race. Let's deploy the process to JBoss by switching on the JBoss Server View. Right-click on the JBoss server and select Add and remove projects. Add the EnterpriseStore to the configured projects.

Now deploy the application in the usual way. Right-click on the EnterpriseStore and select Full Publish (at the time of writing, JBoss 5 doesn't support partial deployment of this component).

Verify from the console that the application has been deployed correctly.

Running the store

The application gateway will be home.jsf page. Point the browser to the location http://localhost:8080/AppStoreWeb/home.jsf.

Testing the application is quite simple. First add some customers and then link some orders to the customers. In the home.jsf page, check that the orders are correctly listed from the datagrid.

A last trick
Usually web applications ship with a welcome file list so that you don't have to remember anything else besides the web context. If you have already tried to add home.jsf to the welcome file list (in web.xml), you would have noticed that it doesn't work. Actually, Tomcat is a bit stubborn and requires a trick to set a JSF page as a welcome file. First, add the following to your web.xml:

<welcome-file-list>
<welcome-file>home.jsf</welcome-file>
</welcome-file-list>

Then create an empty home.jsf page in your web context root. This will trick Tomcat to detect home.jsf as the welcome file and will load home.jsp instead.

Summary

This two-part article on creating a web application is about developing and configuring web applications on JBoss AS 5.0 using the JSF cutting-edge technology. In this part of the article we have enhanced the Appstore Enterpirse application by adding a web layer to it.

An Ajax client responds much faster to the user's actions and can provide desktop-like features, increasing user productivity. Instead of regenerating the HTML markup for every request on the server side, the user interface (UI) is loaded once in the browser and then the Ajax client retrieves only the data that it needs, updating the user interface dynamically. In addition, many data requests are sent asynchronously, meaning that they don't block the UI.

In this article, I'll show you how to build a Web-based table editor that allows the user to insert/delete rows and undo changes without waiting for a server response and without losing the scroll position. The table component will also act as a viewer that uses Ajax to retrieve information from a data feed. You'll learn how to use JavaScript to build a table model, create the table editor/viewer, validate data with regular expressions, access the data feed, use event handlers, and monitor the data changes in the Web browser. In addition, I'll present a very interesting technique for generating XML and HTML on the client side, using a JSP-like syntax that makes the code more readable and easier to maintain.

Application Overview

The sample application of this article is a portfolio editor/viewer:

The user enters the stock information and is able to undo the data changes at any moment. The share prices are retrieved from a data feed so that the stock values and their gains/losses can be updated every second. When the user saves the data, the table component is switched to a read-only mode:

I have already presented half of the application's code in a previous OTN article titled "Enabling Data Exchange in Ajax Applications," and the Ajax utility functions (contained in the ajaxUtil.js file) are reused from another OTN article of mine titled "Developing Smart Web UIs with Ajax, JSF, and ADF Faces." The following table specifies the article that describes each source file and the directory where you can find the file:

Data Models and Data Feeds

Like any typical Web application, the portfolio sample has a server-side data model, which was described in "Enabling Data Exchange in Ajax Applications." The DataModel class can be initialized from an XML document, and its state can be encoded as a JSON string that is used to initialize the client-side data model, which is presented in this section.

Building Table Models

The portfolio application uses a JavaScript table model that maintains the user data and the information retrieved from the data feed with Ajax. To create the JavaScript file, open JDeveloper, select an existing project or create a new one, click File / New, expand Web Tier in the New Gallery window, select the HTML category in the left panel, select JavaScript File in the right panel and click OK:

Enter the dataModel.js file name and click OK:

The dataModel.js file of the sample application creates an object whose methods are similar to those defined by Swing's TableModel interface: getRowCount(), getColumnCount(), getColumnName(), getValueAt(), and setValueAt(). Here is the code that creates the data model object:

var dataModel = {

    columns: [ "Symbol", "Shares", "Paid Price",
        "Last Price", "Stock Value", "Gain/Loss" ],

    stocks: [ ],

    getRowCount: function() {
        return this.stocks.length;
    },

    getColumnCount: function() {
        return this.columns.length;
    },

    getColumnName: function(index) {
        return this.columns[index];
    },

    getValueAt: function(row, column) {
        ...
    },

    setValueAt: function(value, row, column) {
        ...
    },

    ...
}

The data model object has additional methods that return a stock's value and gain, calculate the portfolio's value and gain, get/set all stocks, insert a new stock, and delete an existing stock. You can find the code of these simple methods in the dataModel.js file.

The JavaScript editor of JDeveloper has many useful features such as syntax highlighting and verification, completion and parameter insight, refactoring, usage finding, brace matching, and code folding. In addition, you can use the Structure Navigator to locate declarations and functions:

The JDeveloper release used here (Oracle JDeveloper 11g Technology Preview 2) also includes a JavaScript debugger for Firefox. To view or change the debugger settings, click Tools / Project Properties, select Run/Debug/Profile in the left panel, choose the Default profile in the right panel, and click Edit:

In the Edit Run Configuration window, select Launch Settings / JavaScript in the left panel so that you can setup the debugger:

Implementing Data Feeds

A data feed usually provides a Web service or an HTTP-based protocol so that it can be accessed over a network. An Ajax client, however, cannot directly connect to third-party Web services due to security restrictions imposed by the Web browser. Therefore, you need an Ajax controller running on the same server that hosts the Ajax application. This controller should connect to the third-party Web service to retrieve the data for the Ajax client. In order to keep things simple and focus on the Ajax topics, the sample application simulates the data feed, generating random share prices in the ShareBean class:

package ajaxapp.feed;

public class ShareBean implements java.io.Serializable {
    private String symbol;
    private int trend;
    private double lastPrice;

    public ShareBean(String symbol) {
        this.symbol = symbol;
        trend = 1;
        lastPrice = Math.random() * 100;
    }

    public String getSymbol() {
        return symbol;
    }

    public int getTrend() {
        return trend;
    }

    public double getLastPrice() {
        lastPrice += trend * Math.random() * 0.1;
        if (Math.random() < 0.2)
            trend = -trend;
        return lastPrice;
    }

}

The DataFeed class provides a getData() method that takes an array of symbols and returns the share information encoded in a JSON string:

package ajaxapp.feed;

import ajaxapp.util.JSONEncoder;

import java.util.*;

public class DataFeed implements java.io.Serializable {
    private HashMap<String, ShareBean> shareMap;

    public DataFeed() {
        shareMap = new HashMap<String, ShareBean>();
    }

    public synchronized String getData(String symbols[]) {
        JSONEncoder json = new JSONEncoder();
        json.startArray();
        for (int i = 0; i < symbols.length; i++) {
            String symbol = symbols[i];
            ShareBean share = shareMap.get(symbol);
            if (share == null) {
                share = new ShareBean(symbol);
                shareMap.put(symbol, share);
            }
            json.startObject();
            json.property("symbol", share.getSymbol());
            json.property("trend", share.getTrend());
            json.property("lastPrice", share.getLastPrice());
            json.endObject();
        }
        json.endArray();
        return json.toString();
    }

    public static String getData(
            DataFeed feed, String symbols[]) {
        return feed.getData(symbols);
    }

}

The static getData() method is useful for calling the instance method from a JSP page, using an expression language (EL) function that is defined in feed.tld. To create the TLD file, click File / New, select the JSP category from Web Tier in the left panel, select the JSP Tag Library item and click OK:

Skip the Welcome screen of the wizard and select Project Based:

Provide the feed short name, enter the /ajaxapp/feed URI and click Finish:

Then, paste the <function> element shown below:

<?xml version="1.0" encoding="UTF-8" ?>
<taglib ...>

    <tlib-version>1.0</tlib-version>
    <short-name>feed</short-name>
    <uri>/ajaxapp/feed</uri>

    <function>
        <name>getData</name>
        <function-class>ajaxapp.feed.DataFeed</function-class>
        <function-signature>
            java.lang.String getData(
                ajaxapp.feed.DataFeed, java.lang.String[])
        </function-signature>
    </function>

</taglib>

The application's Ajax controller (called ajaxCtrl.jsp) uses the getData() EL function to obtain the share prices for the Ajax client. A DataFeed instance is used as an application bean in the ajaxCtrl.jsp file:

<%@ taglib prefix="tags" tagdir="/WEB-INF/tags/" %>
<%@ taglib prefix="feed" uri="/WEB-INF/feed.tld" %>

<tags:setHeader name="Cache-Control" value="no-cache"/>

<jsp:useBean id="dataFeed" scope="application"
	class="ajaxapp.feed.DataFeed" />
...
${feed:getData(dataFeed, paramValues.symbol)}

It is important to set the no-cache header in order to disable the Web browser's cache. Here is the code of the setHeader.tag file:

<%@ attribute name="name" required="true" %>
<%@ attribute name="value" required="true" %>

<%
    String name = (String) jspContext.getAttribute("name");
    String value = (String) jspContext.getAttribute("value");
    response.setHeader(name, value);
%>

Now that we have implemented a data feed on the server side, let's see how to access it from the Ajax client.

Accessing Data Feeds

The Ajax client sends an HTTP request to the controller, which calls the getData() method and returns the JSON string. The HTTP request must contain the parameters, which are the share symbols in the case of this example. The requestFeedInfo() function (whose code can be found in dataTable.js) gets the symbols from the data model and makes sure that each symbol is included only once, because the portfolio could contain multiple stocks with the same symbol:

function requestFeedInfo() {
    var symbolSet = new Array();
    for (var i = 0; i < dataModel.stocks.length; i++) {
        var symbol = dataModel.stocks[i].symbol;
        if (isValidSymbol(symbol)) {
            for (var j = 0; j < symbolSet.length; j++)
                if (symbol == symbolSet[j].value)
                    symbol = null;
            if (symbol)
                symbolSet[symbolSet.length] = symbol;
        }
    }
    if (symbolSet.length > 0)
        sendInfoRequest(symbolSet, feedInfoCallback);
}

The array of symbols is passed to sendInfoRequest() along with feedInfoCallback, which will be invoked when the data is received from the server. The sendInfoRequest() function aborts the previous HTTP request if it hasn't been completed, and then it builds the array of HTTP parameters that is passed to sendHttpRequest(), which builds and sends the request to the server, using the Ajax API. The sendHttpRequest() function can be found in the ajaxUtil.js file whose code was discussed in a previous OTN article entitled "Developing Smart Web UIs with Ajax, JSF, and ADF Faces." Here is the code of the sendInfoRequest() function from ajaxLogic.js:

var ctrlURL = "ajaxCtrl.jsp";
var feedRequest = null;

function sendInfoRequest(symbols, callback) {
    if (feedRequest)
        abortRequest(feedRequest);
    var params = new Array();
    for (var i = 0; i < symbols.length; i++)
        params[i] = {
            name: "symbol",
            value: symbols[i]
        };
    feedRequest = sendHttpRequest(
        "GET", ctrlURL, params, callback);
}

The Ajax callback can be found in the dataTable.js file. The feedInfoCallback() function evaluates the JSON response with eval(request.responseText), obtaining an object tree that contains the information retrieved from the data feed. Then, it stores the latest share prices into the data model and calls updateDynamicCells() for updating the UI:

function feedInfoCallback(request) {
    var feedInfo = eval(request.responseText);
    for (var i = 0; i < dataModel.stocks.length; i++) {
        var symbol = dataModel.stocks[i].symbol;
        dataModel.stocks[i].lastPrice = 0;
        for (var j = 0; j < feedInfo.length; j++)
            if (symbol == feedInfo[j].symbol) {
                var value = feedInfo[j].lastPrice;
                dataModel.stocks[i].lastPrice = value;
            }
    }
    updateDynamicCells();
}

Before discussing the UI code, let's see how you can use JavaScript to generate XML and HTML in the Web browser.

Generating XML and HTML with JavaScript

Before JSP, servlets were used to dynamically generate HTML content on the server side. It was difficult to create and maintain the servlet code, because the developer had to manually encode HTML strings within the Java code and each line of markup had to be placed in a println() statement. It was difficult to view the page structure, and it wasn't possible to use visual tools for designing the pages that were coded as servlets.

Today, servlets are doing very well as the foundation of the JSP technology, which provides a much better way for generating markup on the server side. On the client side, however, JavaScript has no JSP equivalent. Many developers use servlets-like coding techniques to dynamically create HTML content, or they use the DOM API. None of these solutions is easy to use when you have to generate HTML or XML with JavaScript.

Using a JSP-like Syntax with JavaScript

It would be much easier to use something like this

<tag attr="[%= value %]"> [%= data %] </tag>

instead of

"<tag attr=\"" + escapeXML(value) + "\">" + escapeXML(data) + "</tag>"

You wouldn't have to escape " with \ anymore, and expressions included within the [%= %] constructs would be automatically escaped, meaning that &, <, >, and " would be replaced with &amp;, &lt;, &gt;, and &quot;, respectively. Sometimes you already have a piece of markup and you don't want to escape &, <, >, and ". In this case, you could use [%# %] instead of [%= %].

So you can easily view the markup's structure, the blocks of JavaScript code can be wrapped between [% and %] as in the following example:

<table class="tableClass"> [%
    for (var i = 0; i < rowCount; i++) { %]
        <tr class="[%= getRowClass(i) %]"> [%
            for (var j = 0; j < columnCount; j++) { %]
                <td class="[%= getCellClass(i, j) %]">
                    [%# buildCell(i, j) %]
                </td> [%
            } %]
        </tr> [%
    } %]
</table>

The above template must be translated into valid JavaScript code on the server side. Here is how this should look:

var content = "";
content += "<table class=\"tableClass\">";
for (var i = 0; i < rowCount; i++) {
    content += "<tr class=\"";
    content += escapeXML(getRowClass(i));
    content += "\">";
    for (var j = 0; j < columnCount; j++) {
        content += "<td class=\"";
        content += escapeXML(getCellClass(i, j));
        content += "\">";
        content += buildCell(i, j);
        content += "</td>";
    }
    content += "</tr>";
}
content += "</table>";

As you can see, the code is much easier to read and maintain when you use the JSP-like syntax. Let's see how to generate the JavaScript code from the template.

Creating the Code Generator

The JSBuilder class (of the ajaxapp.builder package) parses the template and generates the JavaScript code. In addition, the JSONEncoder class (of the ajaxapp.util package) provides the means for encoding the JavaScript strings with the character() and string() methods:

package ajaxapp.util;

public class JSONEncoder {
    private StringBuilder buf;

    public JSONEncoder() {
        buf = new StringBuilder();
    }

    public void character(char ch) {
        switch (ch) {
            case '\'':
            case '\"':
            case '\\':
                buf.append('\\');
                buf.append(ch);
                break;
            ...
            default:
                if (ch >= 32 && ch < 128)
                    buf.append(ch);
                else {
                    ...
                }
        }
    }

    public void string(String str) {
        int length = str.length();
        for (int i = 0; i < length; i++)
            character(str.charAt(i));
    }

    ...

    public String toString() {
        ...
        return buf.toString();
    }

    public void clear() {
        buf.setLength(0);
    }

}

The character() and string() methods of the JSONEncoder class need some modifications so they can be used by the code generator. Therefore the createEncoder() method of JSBuilder uses an inner class that overrides character() to output a JavaScript line when it meets the '\n' character. The string() method will output the last line, which might not end with the new line character.

package ajaxapp.builder;

import ajaxapp.util.JSONEncoder;

public class JSBuilder {
    ...
    private JSONEncoder json;
    private String varName;
    private boolean isHTML;
    private PrintWriter out;

    public JSBuilder() {
        json = createEncoder();
    }

    private JSONEncoder createEncoder() {
        return new JSONEncoder() {
            private void outputLine() {
                String line = toString();
                out.println(varName + " += \"" + line + "\";");
                clear();
            }

            public void character(char ch) {
                super.character(ch);
                if (ch == '\n')
                    outputLine();
            }

            public void string(String str) {
                super.string(str);
                if (toString().length() > 0)
                    outputLine();
            }
        };
    }
    ...
}

The printContent() method uses the customized encoder to generate the JavaScript code that reconstructs a piece of HTML or XML content on the client side:

public class JSBuilder {
    ...
    private void printContent(String content) {
        json.clear();
        json.string(content);
    }
    ...
}

The printExpr() method generates the code that escapes and appends an expression:

public class JSBuilder {
    ...
    private void printExpr(String expr, boolean escapeXML) {
        if (escapeXML)
            expr = "escapeXML(" + expr + ", " + isHTML + ")";
        out.println(varName + " += " + expr + ";");
    }
    ...
}

The escapeXML() JavaScript function is included in the ajaxUtil.js file.

The build() method parses the template and generates the JavaScript code:

public class JSBuilder {
    public static final String CODE_STARTER = "[%";
    public static final String CODE_ENDER = "%]";
    public static final char EXPR_STARTER = '=';
    public static final char INCL_STARTER = '#';
    ...
    public void build(String template, String varName,
            Writer writer, boolean isHTML) {
        this.varName = varName;
        this.isHTML = isHTML;
        out = new PrintWriter(writer, true);
        out.println("var " + varName + " = \"\";");
        int contentStart = 0;
        int contentEnd = template.indexOf(CODE_STARTER);
        while (contentEnd != -1) {
            String content = template.substring(
                    contentStart, contentEnd);
            printContent(content);
            int codeStart = contentEnd + 2;
            int codeEnd = template.indexOf(CODE_ENDER, codeStart);
            if (codeEnd == -1) {
                codeEnd = template.length();
                template += CODE_ENDER;
            }
            char starter = template.charAt(codeStart);
            if (starter == EXPR_STARTER || starter == INCL_STARTER) {
                codeStart++;
                String expr = template.substring(codeStart, codeEnd);
                printExpr(expr, starter == EXPR_STARTER);
            } else {
                String code = template.substring(codeStart, codeEnd);
                out.println(code);
            }
            contentStart = codeEnd + 2;
            contentEnd = template.indexOf(CODE_STARTER, contentStart);
        }
        String content = template.substring(contentStart);
        printContent(content);
    }

}

With fewer than 100 lines of code, we've built a template parser / code generator, which significantly improves the readability and maintainability of the JavaScript code that dynamically produces HTML or XML on the client-side.

Using the Code Generator in JSP Pages

In order to keep the JSP pages scriptless, the JSBuilder's build() method can be invoked from a custom tag file (named template.tag), which will generate a JavaScript function that returns the generated content. The function's header can be provided via an attribute, and the template can be placed between the start tag and the end tag. Here is the syntax of the custom tag:

<tags:template function="myTemplate(...)">
     ... template ...
</tags:template>

To create the tag file, click File / New, expand Web Tier in the New Gallery window, select the JSP category in the left panel, select JSP Tag File in the right panel, and click OK:

Enter the template.tag file name and click OK:

Then, paste the following source code. The <jsp:doBody> action is used in the tag file to obtain the template�s body, which is stored in a JSP variable. Then, the template is passed to the build() method, which generates the JavaScript code that will produce the content on the client side. Here is the code of the template.tag file:

<%@ attribute name="function" required="true" %>
<%@ attribute name="isHTML" required="false"
    type="java.lang.Boolean" %>
<%@ tag import="ajaxapp.builder.JSBuilder" %>

<script language="javascript">

    function ${function} {
        <jsp:doBody var="templateBody"/>
        <%
            Boolean isHTML
                = (Boolean) jspContext.getAttribute("isHTML");
            if (isHTML == null)
                isHTML = new Boolean(false);
            String templateBody
                = (String) jspContext.getAttribute("templateBody");
            new JSBuilder().build(templateBody, "content",
                jspContext.getOut(), isHTML.booleanValue());
        %>
        return content;
    }

</script>

The index.jsp page of the sample application uses the template tag to generate JavaScript functions that produce dynamic HTML content as well as an XML document containing the portfolio�s data. You'll see later in the article how the HTML pieces are inserted into the Web page with innerHTML. The XML document is sent to the server with XMLHttpRequest.

You can use Oracle JDeveloper to insert the tag into the JSP page. Select Local Tag Files: /WEB-INF/tags/ in the Component Palette. Then, drag Template from the palette and drop it on the head tag, which is shown in the Structure Navigator. JDeveloper starts a wizard that lets you enter the required function attribute in the Common Properties tab and the optional isHTML attribute in the Advanced Properties tab. Enter the buildPortfolioDoc() function header, and click Finish:

JDeveloper will insert the <tags:template> tag within the <head> element of the JSP page. After that, you may enter the template�s body. Here is the code that generates JavaScript function, which returns the portfolio XML document:

<tags:template function="buildPortfolioDoc()">
    <portfolio> [%
        var stocks = dataModel.stocks;
        for (var i = 0; i < stocks.length; i++) {
            var stock = stocks[i]; %]
            <stock symbol="[%= stock.symbol %]"
                shares="[%= stock.shares %]"
                paidPrice="[%= stock.paidPrice %]"/> [%
        } %]
    </portfolio>
</tags:template>

The next section shows how to use the custom tag for building the table editor/viewer.

Table Editors and Viewers

There are many cases when a table component must change dynamically in response to the user's actions. For example, a row could be inserted or deleted when the user clicks a button. If the table's content is recreated on the server, the user must wait while the table is reloaded and the scroll position is lost. If the user has just inserted an empty row, he/she must scroll down to find the new line where data must be entered. This is a time-consuming operation that can be avoided, using Ajax and DHTML.

Initializing the User Interface

The application's main page (index.jsp) declares the used tag libraries, JavaScript files, and style sheet:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="tags" tagdir="/WEB-INF/tags/" %>

<html>
<head>

<link rel="stylesheet" href="style.css" type="text/css">

<script src="ajaxUtil.js"></script>
<script src="ajaxLogic.js"></script>
<script src="dataModel.js"></script>
<script src="dataTable.js"></script>

...
</head>
...
</html>

You can use JDeveloper's editors and wizards to build JSP pages. To insert a JSP directive or a standard action, select JSP in the Component Palette, and then click or drag the desired element:

Click Taglib Directive and select a JSP library that you want to use in the Web page:

You can also use JDeveloper to insert HTML tags in a Web page. Select HTML in the Component Palette, select the Common category, and click Script. Then select the JavaScript file whose functions you want to call in the Web page:

The body of the index.jsp page contains two elements (<span> and <div>) whose content will be set later with the help of innerHTML. The onLoad attribute indicates the function that the browser must call after loading the page:

<body onLoad="init()">

<h1 align="center"><span id="title"></span></h1>

<div id="dataTable">
</div>

</body>

The init() function tries to load the portfolio, using the sendLoadRequest() utility from the ajaxLogic.js file. If the loading succeeds, stocks are stored into the client-side data model and the editing flag is set to false. Otherwise, init() adds three empty rows and sets the editing mode. The requestFeedInfo() function is scheduled with setInterval() to be called every second:

function init() {
    var stocks = sendLoadRequest();
    if (stocks && stocks.length > 0) {
        dataModel.setStocks(stocks);
        addDataChange();
        setEditing(false);
    } else {
        for (var i = 0; i < 3; i++)
            dataModel.insertStock(i);
        addDataChange();
        setEditing(true);
    }
    setInterval("requestFeedInfo()", 1000);
}

Using Cascading Style Sheets

The sample application uses the following CSS file:

BODY { background: #FFFFFF; color: #000000; }
TH { font-weight: bold;
     background-color: #EEF8FF;
     border-top: 1px solid #CCCCCC;
     border-right: 1px solid #CCCCCC;
     border-bottom: 1px solid #CCCCCC; }
TD { font-weight: normal;
     background-color: #FFFFFF;
     border-right: 1px solid #CCCCCC;
     border-bottom: 1px solid #CCCCCC; }
TH.symbol, TD.symbol { text-align: left;
     border-left: 1px solid #CCCCCC; }
TH.number, TD.number { text-align: right; }
TD.button { text-align: center; }
TD.leftButton { text-align: center;
     border-left: 1px solid #CCCCCC; }
BUTTON { background-color: #EEEEEE; }
INPUT.valid { background-color: #FFFFFF; }
INPUT.error { background-color: #FFEEEE; }
SPAN.gain { color: #008000; }
SPAN.loss { color: #FF0000; }
A:link, A:visited { color: #000000;
     text-decoration: underline; }
A:hover, A:active { color: #FF0000;
     text-decoration: underline; }

You can use Oracle JDeveloper to enter the values of the CSS properties:

Creating Tables with JavaScript

The JavaScript code that builds the sample application's table is generated in the index.jsp file with the custom template tag presented in the previous section. Here is the code for building a single cell of the table:

<tags:template function="buildCell(row, column)" isHTML="true"> [%
    var value = "";
    if (!isDynamic(row, column))
        value = dataModel.getValueAt(row, column);
    if (isEditable(row, column)) {
        var id = getInputId(row, column); %]
        <input id="[%= id %]" name="[%= id %]" value="[%= value %]"
            type="text" size="[%= column == 2 ? 6 : 4 %]"
            onKeyUp="validateCellData([%= row %], [%= column %])"
            onChange="dataChanged([%= row %], [%= column %])"> [%
    } else {
        var id = getSpanId(row, column); %]
        <span id="[%= id %]">[%= value %]</span> [%
    } %]
</tags:template>

The dataTable.js file contains the JavaScript functions that are called from the template code. The isDynamic() function returns true if the cell's value is computed using data that is retrieved from the feed:

function isDynamic(row, column) {
    return column >= 3;
}

The isEditable() function returns true if the user can modify the cell's value:

function isEditable(row, column) {
    return isEditing() && column < 3;
}

The getInputId() and getSpanId() functions return the IDs of the <input> and <span> elements of the cells:

function getInputId(row, column) {
    return "input_" + row + "_" + column;
}

function getSpanId(row, column) {
    return "span_" + row + "_" + column;
}

The buttons and links are generated with another template. The buildButton() function accepts three parameters: the button's label, the event handler that must be called when the button (or the link) is clicked, and an optional parameter for the handler function:

<tags:template function="buildButton(label, handler, param)"
         isHTML="true"> [%
    if (!param) param = ""; %]
    <c:if test="${initParam.useButtons}">
        <button onClick="[%# handler %]([%# param %])" type="button">
            [%= label %]
        </button>
    </c:if>
    <c:if test="${!initParam.useButtons}">
        <a href="javascript:[%# handler %]([%# param %])">
            [%= label %]
        </a>
    </c:if>
</tags:template>

The useButtons parameter, which is configured in the web.xml file, determines whether buildButton() generates a button or a link:

<web-app ...>

    <context-param>
        <param-name>useButtons</param-name>
        <param-value>true</param-value>
    </context-param>
    ...
</web-app>

The table's template starts with the header that contains the column names. The buildCell() and buildButton() functions are used to generate the content of the cells. The last row contains additional buttons and the totals:

<tags:template function="buildTable()" isHTML="true">
    <table border=0 cellpadding=5 cellspacing=0 align="center">
        <tr> [%
            var columnCount = dataModel.getColumnCount();
            for (var j = 0; j < columnCount; j++) { %]
                <th class="[%= j == 0 ? "symbol" : "number" %]">
                    [%= dataModel.getColumnName(j) %]
                </th> [%
            }
            if (isEditing()) { %]
                <th class="header" colspan="2"> </th> [%
            } %]
        </tr> [%
        var rowCount = dataModel.getRowCount();
        for (var i = 0; i < rowCount; i++) { %]
            <tr> [%
                for (var j = 0; j < columnCount; j++) { %]
                    <td class="[%= j == 0 ? "symbol" : "number" %]">
                        [%# buildCell(i, j) %]
                    </td> [%
                }
                if (isEditing()) { %]
                    <td class="button">
                        [%# buildButton("Insert", "insertAction", i) %]
                    </td>
                    <td class="button">
                        [%# buildButton("Delete", "deleteAction", i) %]
                    </td> [%
                } %]
            </tr> [%
        } %]
        <tr>
            <td class="leftButton" colspan="3"> [%
                if (isEditing()) { %]
                    [%# buildButton("Save", "saveAction") %] [%
                } else { %]
                    [%# buildButton("Edit", "editAction") %] [%
                } %]
            </td>
            <td class="number">Total:</td>
            <td class="number"><span id="totalValue"></span></td>
            <td class="number"><span id="totalGain"></span></td> [%
            if (isEditing()) { %]
                <td class="button">
                    [%# buildButton("Add", "insertAction", rowCount) %]
                </td>
                <td class="button">
                    [%# buildButton("Undo", "undoAction") %]
                </td> [%
            } %]
        </tr>
    </table>
</tags:template>

The generated buildTable() function is called from updateTableComponent(), whose code can be found in the dataTable.js file:

function updateTableComponent() {
    getElementById("dataTable").innerHTML = buildTable();
    updateDynamicCells();
    requestFeedInfo();
    if (isEditing())
        validateTableData();
}

The getElementById() function calls the document's getElementById(), which returns the DOM object representing the HTML element that has the given ID:

function getElementById(id) {
    return document.getElementById(id);
}

The isEditing() function returns the value of the editing flag, which indicates whether the table component is in editing or viewing mode:

var editing = false;
...
function isEditing() {
    return editing;
}

In addition to setting the editing flag, the setEditing() function modifies the page's title and updates the table component:

function setEditing(value) {
    editing = value;
    var title = "AJAX-based Portfolio "
        + (editing ? "Editor" : "Viewer");
    getElementById("title").innerHTML = title;
    updateTableComponent();
}

Validating Table Editor's Data

Regular expressions provide an easy way to validate data with JavaScript. For example, a share symbol can be validated with the following function, whose code can be found in dataTable.js:

function isValidSymbol(symbol) {
    return symbol && (symbolRE.exec(symbol) == symbol);
}

The sample application uses three regular expressions for validating the user input:

var symbolRE = /[A-Za-z][A-Za-z][A-Za-z][A-Za-z]?/;
var numberRE = /\d+/;
var priceRE = /\d+\.?\d*/;

The validateCellData() function validates the value of a single cell:

function validateCellData(row, column) {
    if (!isEditable(row, column))
        return true;
    var valid = false;
    var inputElem = getElementById(getInputId(row, column));
    var value = inputElem.value;
    if (value) {
        var regexp = null;
        switch (column) {
            case 0: regexp = symbolRE; break;
            case 1: regexp = numberRE; break;
            case 2: regexp = priceRE; break;
        }
        if (regexp != null)
            valid = regexp.exec(value) == value;
    }
    inputElem.className = valid ? "valid" : "error";
    return valid;
}

User errors are signaled with the pink color of the error style:

The validateTableData() function verifies the data of the whole table:

function validateTableData() {
    var allValid = true;
    for (var i = 0; i < dataModel.getRowCount(); i++)
        for (var j = 0; j < dataModel.getColumnCount(); j++) {
            var valid = validateCellData(i, j);
            allValid = allValid && valid;
        }
    return allValid;
}

Data should be revalidated on the server for security reasons. The sample application (download) uses the portfolio.xsd schema for this operation.

Refreshing Table Viewer's Data

In a JavaScript application, data can be formatted using custom utilities, such as the formatPrice() function, which returns a string representation of a numeric price:

function formatPrice(value) {
    var n = new Number(value);
    if (isNaN(n) || n == 0)
        return " ";
    return n.toFixed(2);
}

The updateDynamicCells() function updates all dynamic cells of the table. After locating the <span> element of each dynamic cell, the content is changed, using the innerHTML property of the <span> element. If the cell represents a gain or a loss, its style can be changed too, using the className property of the same <span> element:

function updateDynamicCells() {
    for (var i = 0; i < dataModel.getRowCount(); i++) {
        for (var j = 0; j < dataModel.getColumnCount(); j++) {
            if (isDynamic(i, j)) {
                var value = dataModel.getValueAt(i, j);
                var spanElem = getElementById(getSpanId(i, j));
                spanElem.innerHTML = formatPrice(value);
                if (j == 5)
                    spanElem.className = value >= 0 ? "gain" : "loss";
            }
        }
    }
    var totalValue = dataModel.getTotalValue();
    var totalValueElem = getElementById("totalValue")
    totalValueElem.innerHTML = formatPrice(totalValue);
    var totalGain = dataModel.getTotalGain();
    var totalGainElem = getElementById("totalGain")
    totalGainElem.innerHTML = formatPrice(totalGain);
    totalGainElem.className = totalGain >= 0 ? "gain" : "loss";
}

Using Event Handlers

The dataTable.js file contains the code that handles the UI events. Every time the user changes the value of a cell, the browser calls the dataChanged() function, whose call is coded in value of the onChange attribute of each <input> element. The dataChanged() function validates the cell's data, stores the new value in the data model, updates the dynamic cells, and requests the feed information just in case the user entered a new symbol:

function dataChanged(row, column) {
    validateCellData(row, column);
    var inputElem = getElementById(getInputId(row, column));
    dataModel.setValueAt(inputElem.value, row, column);
    addDataChange();
    updateDynamicCells();
    requestFeedInfo();
}

The addDataChange() function saves the stocks into the dataChanges array:

var dataChanges = new Array();
...
function addDataChange() {
    dataChanges[dataChanges.length]
        = dataModel.getStocks();
}

The undoAction() function is called each time the user clicks the Undo button. The previous stocks are retrieved from the dataChanges array. Then, the data model and the table are updated:

function undoAction() {
    if (dataChanges.length >= 2) {
        var stocks = dataChanges[dataChanges.length-2];
        dataChanges.length--;
        dataModel.setStocks(stocks);
        updateTableComponent();
    }
}

The insertAction() function inserts a new row:

function insertAction(row) {
    dataModel.insertStock(row);
    addDataChange();
    updateTableComponent();
}

The deleteAction() function deletes a row:

function deleteAction(row) {
    dataModel.deleteStock(row);
    addDataChange();
    updateTableComponent();
}

The saveAction() function sends the portfolio's data to the server, using the buildPortfolioDoc() function that is generated in index.jsp and the sendSaveRequest() function whose code can be found in ajaxLogic.js. The portfolio is saved only if the entire table's data is valid:

function saveAction() {
    if (validateTableData()) {
        sendSaveRequest(buildPortfolioDoc());
        setEditing(false);
    } else {
        alert("Please provide valid values for the pink fields.");
    }
}

The editAction() function just calls setEditing(true):

function editAction() {
    setEditing(true);
}

Summary

In this article, you've learned how to build Swing-like table models and implement data feeds that are accessed with the help of Ajax. Then, you've seen how to use a JSP-like syntax for generating HTML and XML with JavaScript. Finally, you've found out how to build table components, validate and format their data with JavaScript, define their appearance with CSS, handle events, and undo the data changes.

Due to the fact that writing a Java app to control your Twitter account is quite a long process and requires several features, I intend to divide this article in several sections, so you can see in extreme detail all the bells and whistles involved in writing Java applications.

Downloading and installing NetBeans for your developing platform

To download NetBeans, open a web browser window and go to the NetBeans website. Then click on the Download button and select the All IDE download bundle. After downloading NetBeans, install it with the default options.

Creating your SwingAndTweet project

1. Open NetBeans and select File | New Project to open the New Project dialog. Now select Java from the Categories panel and Java Application from the Projects panel. Click on Next to continue.
2. The New Java Application dialog will show up next. Type SwingAndTweet in the Project Name field, mark the Use Dedicated Folder for Storing Libraries option, deselect the Create Main Class box (we’ll deal with that later), make sure the Set as Main Project box is enabled and click on Next to continue:

   

3. NetBeans will create the SwingAndTweet project and will show it under the Projects tab, in the NetBeans main window. Right click on the project’s name and select JFrame Form… in the pop-up menu:

   

4. The New JFrame Form window will appear next. Type SwingAndTweetUI in the Class Name field, type swingandtweet in the Package field and click on Finish to continue:

   

5. NetBeans will open the SwingAndTweetUI frame in the center panel of the main screen. Now you’re ready to assemble your Tweeter Java application!
6. Now let me explain a little bit about what we did in the previous exercise: First, we created a new Java application called SwingAndTweet. Then we created a Swing JFrame component and we named it SwingAndTweetUI, because this is going to act as the foundation, where we’re going to put all the other Swing components required to interact with Twitter. Now I’m going to show you how to download and integrate the Twitter4J API to your SwingAndTweetJava application.

Downloading and integrating the Twitter4J API into your NetBeans environment

For us to be able to use the powerful classes and methods from the Twitter4J API, we need to tell NetBeans where to find them and integrate them into our Java applications.

1. Open a web browser window, go to http://repo1.maven.org/maven2/net/homeip/yusuke/twitter4j/ and search for the latest twitter4j.2.X.X.jar file, or download the most recent version at the time of this writing from here:http://repo1.maven.org/maven2/net/homeip/yusuke/twitter4j/2.0.9/twitter4j-2.0.9.jar.
2. Once you download it in your computer, go to NetBeans, right-click on the SwingAndTweet project and select Properties from the context menu. Once at the project properties screen, select the Libraries category under the Categories panel, click on the Add JAR/Folder… button at the middle-right part of the screen to open the Add JAR/Folder dialog, navigate to the directory where you downloaded the twitter4j-2.X.X.jar file and double click on it to add it to your project’s library path:

   

3. Click on OK to close the Project Properties dialog and return to the NetBeans main screen.

Ok, you have integrated the Twitter4J API to your SwingAndTweet application. Now, let’s see how to log into your Twitter account from our Java application…

Logging into Twitter from Java and seeing your last Tweet

In the following exercise, I’ll show you how easy it is to start communicating with Twitter from a Java application, thanks to the Twitter class from the Twitter4J API. You‘ll also learn how to check your last tweet through your Java application.

Let’s see how to log into a Twitter account:

1. Go to the Palette window and locate the JLabel component under the Swing Controls section; then drag and drop it into the TweetAndSwing JFrame component:

   

2. Now drag a Button and a Text Editor, too. Once you have the three controls inside the SwingAndTweetUI JFrame control, arrange them as shown below:

   

3. The next step is to change their names and captions, to make our application look more professional. Right click on the JLabel1 control, select Edit from the context menu, type My Last Tweet and hit Enter. Do the same procedure with the other two controls: erase the text in the jTextField1 control and type Login in the jButton1 control.
4. Rearrange the jLabel1 and jTextField1 controls, and drag one of the ends of jTextField1 to increase its length all you can. Once done, your application will look like this:

   

5. 5. And now, let’s inject some life to our application! Double click on the JButton1 control to open your application’s code window. You’ll be inside a java method called jButton1ActionPerformed. This method will execute every time you click on the Login button, and this is where we’re going to put all the code for logging into your Twitter account.
   6. Delete the // TODO add your handling code here: line and type the following code inside the JButton1ActionPerformed method:

      

      Remember to replace username and password with your real Twitter username and password.

   7. If you look closely at the line numbers, you‘ll notice there are five error icons on lines 82, 84, 85,  88 and 89. That’s because we need to add some import lines at the beginning of your code, to indicate NetBeans where to find the Twitter and JOptionPane classes, and the TwitterException.
   8. Scroll up until you locate the package swingandtweet; line; then add the following lines:

      

   9. Now all the errors will disappear from your code. To see your Java application in action, press F6 or select Run  Run | Main Project from the NetBeans main menu. The Run Project window will pop up, asking you to select the main class for your project. The swingandtweet.SwingAndTweetUI class will already be selected, so just click on OK to continue.
   10. Your SwingAndTweetUI application window will appear next, showing the three controls you created. Click on the Login button and wait for the SwingAndTweet application to validate your Twitter username and password. If they’re correct, the following dialog will pop up:

       

   11. Click on OK to return to your SwingAndTweet application. Now you will see your last tweet on the textbox control:

       

   12. If you want to be really sure it’s working, go to your Twitter account and update your status through the Web interface; for example, type Testing my Java app. Then return to your SwingAndTweet application and click on the Login button again to see your last tweet. The textbox control will now reflect your latest tweet:

       

   13. As you can see, your SwingAndTweet Java application can now communicate with your Twitter account! Click on the X button to close the window and exit your SwingAndTweet application.

   Examining the code

   Ok, I know this is a very simple example, but nevertheless we need to look at the code you wrote, because it will be the clue to add more features to your new Java app, like seeing your followers, the people you follow, the latest tweets from you and the people you follow, and what’s more important, you’ll be able to update your status without having to log into the Web interface anymore!

   And know let’s talk about the code. Below you’ll find the complete code for the jButton1ActionPerformed method, so you don’t have to go back and forth between this article and your code:
   

   try {
              Twitter twitter = new Twitter("alromeromx", "Nina1976742");
              twitter.verifyCredentials();
              JOptionPane.showMessageDialog(null, "You're logged in!");
              java.util.List<Status> statusList = twitter.getUserTimeline();
              String s = String.valueOf(statusList.get(0).getText());
              jTextField1.setText(s);
           } catch (TwitterException e) {
   
   	JOptionPane.showMessageDialog (null, "Login failed");
   
   	}
   

   The first thing to notice is that all the code is surrounded by a try-catch statement. For those of you who haven’t worked with try-catch, just keep in mind that the try block contains the code that will execute until an error shows up; in this case, if the SwingAndTweet application can log into your Twitter account, the try block will execute completely, and the catch block will not execute.

   But if an error occurs when trying to log into your Twitter account, the try block will stop executing after the twitter.verifyCredentials() statement and will jump to the JOptionPane.showMessageDialog (null, "Login failed"); statement inside the catch block. The result will be a dialog box indicating the login process failed, and then the application will return to the main screen, without updating your Twitter status.

   Inside the try block, the first line creates a Twitter object named twitter (yes, I know I could’ve thought of a more creative name) with your username and your password as parameters. The next line:

   twitter.verifyCredentials();
   

   is the one in charge of verifying that you can log into your Twitter account. As I explained before, if an error occurs when trying to log in, an exception will be thrown up and the following lines of code will not execute, because the execution will jump to the line inside the catch block.

   Now, if the login process is successful, the execution will continue with: 

   JOptionPane.showMessageDialog(null, "You're logged in!");
   

   This line is the one that shows the dialog window indicating you could log in successfully to your Twitter account. Then, when you press the OK button on this dialog, it will close and you’ll return to the main screen of your SwingAndTweet application, and the next line of code will execute:

   
   
   java.util.List<Status> statusList = twitter.getUserTimeline();
   

   In this line we create a List object called statusList, and we assign to this object the result returned by the getUserTimeline method of the twitter object. This method returns all the information regarding your 20 most recent Tweets.

   On the next line, we create a String object called s, and we assign to it all the information regarding the text of your first Tweet only, through the statusList.get(0).getText() method. But first we need to use the String.valueOf method to convert the Object value returned by the statusList.get(0).getText() method into a String value that s can receive.

   The last line:

   jTextField1.setText(s);
   

   assigns the value of the s string to the textbox control named jTextField1, so you can see your latest tweet in the SwingAndTweet main window.

   Summary

   In this article, we discussed how to go about building a custom application for Twitter using java and NetBeans.