Here is the step by step procedure to set up the scala(2.9) environment with Netbeans(7.2) on a Windows Vista system

1. Install Netbeans 7.2 Beta if not already installed from here.

2. Download the Scala installable from here. Install Scala on your system.

3. Set the environment variable SCALA_HOME pointing it to the Scala installation directory. (On Windows Vista, Go to Start Menu ->Right click on Computer -> Select Properties -> From the left menu, Click on Advanced system Settings -> Click on the Environment variables button on the bottom right corner -> Create new System variable named SCALA_HOME pointing to the Scala installation directory).

4. Now we need to install Scala plugin for Netbeans. Download the plugin here and extract the content into an appropriate folder.

5. Open Netbeans IDE.

6. On the Menu Bar, choose Tools -> Plugin

7. Choose Downloaded tab. Click on Add Plugins button. Browse to the folder containing scala plugins. Choose all the *.nbm files and hit the Install button on the bottom left corner.

5. You need to hit the Next / Continue button and accept the agreements on all the windows that pop up after that.

Plugin auto installs everything.

6. Create New Project. You should now be able to see a new category named Scala. Choose Scala Application. Choose your project name / location and click on Finish. An object named Main which prints out “Hello World” gets created by default. You can run this file as is by hitting Shift+F6 just to check if the environment is correctly set. HelloWorld should get printed as output.

Writing a first Scala program on Netbeans 7.2 seemed a breeze. No headache of conf file changes. But Netbeans 7.2 does seem a lot lot slower than its earlier version 7.0(I have not tried 7.1). Probably because it still is a Beta version.

Following are some gotchas if you are trying to get Scala to work on Netbeans 7.0 or an earlier version of Scala-

1. After installing the plugin, you should be able to create a new Scala project. In case you are not, check if any of the scala plugins are not activated. Select them and activate them.

2. Error message – Could not load definitions from resource scala/tools/ant/antlib.xml. It could not be found.

Solution – Check if Scala has been correctly installed. Append “-J-Dscala.home=scalahomepath” property to the end of “netbeans_default_options” in NetBeansInstallationPath/etc/netbeans.conf where scalahomepath is the actual path to the Scala installation directory.

Please do let me know how your Scala environment setup with Netbeans went. I will be happy to respond to your questions if any. Please feel free to add your comments below.

Adios until the next post !

• Buy NetBeans Books from Java Books Store

Window System in NetBeans Platform 6.9

Large desktop applications need to provide many different views for visualizing
data. These views have to be managed and shown and the NetBeans Platform 6.9
handles these requirements for you out of the box via its docking framework.

While it once might have been sufficient for a docking framework to provide static
fixed window layouts, today the user expects far more fl exibility. Windows should
be able to be opened, movable, and, generally, customizable at runtime. The user
tends to assume that the positions of views are modifiable and that they persist
across restarts of the application. Not only that, but applications are assumed to be
so fl exible that views should be detachable from the application’s main window,
enabling them to be displayed on multiple monitors at the same time. While once the
simple fact of the availability of menus and toolbars was sufficient, today a far more
dynamic handling is needed so that window content can be adapted dynamically.
Connected to these expectations of fl exibility, plugins are increasingly becoming a
standard technology, with the user assuming their windows to be pluggable, too.

In short, the requirements for window management have become quite complex
and can only be met by means of an external docking framework, otherwise all these
various concerns would need to be coded (and debugged, tested, and maintained)
by hand. The NetBeans Platform 6.9 provides all of these features via its docking
framework, known as the NetBeans Window System. It also provides an APito let
you programmatically access the Window System. Together, the Window System and
its APifulfill all the requirements described above, letting you concentrate on your
domain knowledge and business logic rather than on the work of creating a custom
window management facility for each of your applications.

This chapter teaches you the following:

• How to define views


• How to position views in the main window


• How to customize the default window layout


• How to group views so that they open and close as a unit


• How to change the persistence of views across restarts of the application

Creating a window

The NetBeans Window System simplifies window management by letting you use
a default component for displaying windows. The default component, that is, the
superclass of all windows, is the TopComponent class, which is derived from the
standard JComponent class. It defines many methods for controlling a window
and handles notification of main Window System events.

The WindowManager is the central class controlling all the windows in the
application. Though you can implement this class yourself, this is seldom done
as normally the default WindowManager is sufficient. Similarly, you typically use
the standard TopComponent class, rather than creating your own top-level Swing
components. In contrast to the TopComponent class, the default WindowManager
cannot manage your own top-level Swing components, so these cannot take
advantage of the Window System API.

Now let’s create a TopComponent and let it be an editor for working with tasks. This
is done easily by using the New Window wizard.

1. In the Projects window, right-click the TaskEditor module project node and
   choose New | Window.


2. On the first page of the wizard select Editor for Window Position and Open
   on Application Start. Click Next.





3. In the next page of the wizard, type TaskEditor in Class Name Prefix. This
   prefix is used for all the generated files. It is possible to specify an icon that
   will be displayed in the tab of the new window, but let’s skip that for the
   moment. Click Finish and all the files are generated into your module
   source structure.





4. Next, open the newly created TaskEditorTopComponent and drag the
   TaskEditorPanel from the Palette, which is where you put it at the end
   of the last chapter, onto the form.


5. The size of the component automatically adjusts to the required size of
   the panel. Position the panel with the preferred spacing to the left and top
   and activate the automatic resizing of the panel in horizontal and vertical
   direction. The form should now look similar to the following screenshot:





6. Sta rt the application. You now see a tab containing the new TaskEditor
   Window, which holds your form.

Examining the generated files

You have used a wizard to create a new TopComponent. However, the wizard did
more than that. Let’s take a look at all the files that have been created and at all the
files that have been modified, as well as how these files work together.

The only Java class that was generated is the TopComponent that will contain the
TaskEditor, shown as follows:

	@ConvertAsProperties(dtd = “-//com.netbeansrcp.taskeditor//TaskEditor//

	EN”, autostore = false)

	public final class TaskEditorTopComponent extends TopComponent {

		private static TaskEditorTopComponent instance;

			/** path to the icon used by the component and its open action */

			// static final String ICON_PATH = “SET/PATH/TO/ICON/HERE”;

			private static final String PREFERRED_ID = “TaskEditorTopComponent”;

			public TaskEditorTopComponent() {

				initComponents();

				setName(NbBundle.getMessage(TaskEditorTopComponent.class,

					“CTL_TaskEditorTopComponent”));

				setToolTipText(NbBundle.getMessage(TaskEditorTopComponent.class,

					“HINT_TaskEditorTopComponent”));

				// setIcon(ImageUtilities.loadImage(ICON_PATH, true));

			}

				/**This method is called from within the constructor to

				* initialize the form.

				* WARNING: Do NOT modify this code. The content of this method is

				* always regenerated by the Form Editor.

				*/

				// <editor-fold defaultstate=”collapsed” desc=”Generated Code”>

				private void initComponents() {

					javax.swing.GroupLayout layout = new javax.swing.

							GroupLayout(this);

					this.setLayout(layout);

					layout.setHorizontalGroup(

						layout.createParallelGroup(javax.swing.GroupLayout.

						Alignment.LEADING).addGap(0, 555, Short.MAX_VALUE));

					layout.setVerticalGroup(layout.createParallelGroup(

						javax.swing.GroupLayout.Alignment.LEADING)

						.addGap(0, 442, Short.MAX_VALUE)

					);

				}// </editor-fold>

				// Variables declaration – do not modify

				// End of variables declaration

				/**

					* Gets default instance. Do not use directly: reserved for

					*.settings files only,

					* i.e. deserialization routines; otherwise you could get a

					non-deserialized instance.

					* To obtain the singleton instance, use {@link #findInstance}.

				*/

				public static synchronized TaskEditorTopComponent getDefault() {

					if (instance == null) {

						instance = new TaskEditorTopComponent();

					}

					return instance;

				}

				/**

				* Obtain the TaskEditorTopComponent instance. Never call {

					@link #getDefault} directly!

				*/

				public static synchronized TaskEditorTopComponent findInstance() {

					TopComponent win = WindowManager.getDefault().findTopComponent

							(PREFERRED_ID);

					if (win == null) {

						Logger.getLogger(TaskEditorTopComponent.class.getName()).

							warning(“Cannot find ” + PREFERRED_ID + ” component.

							It will not be located properly in the window system.”);

						return getDefault();

					}

					if (win instanceof TaskEditorTopComponent) {

						return (TaskEditorTopComponent) win;

					}

					Logger.getLogger(TaskEditorTopComponent.class.getName()).

						warning(“There seem to be multiple components with the ‘” +

						PREFERRED_ID

						+ “‘ ID. That is a potential source of errors and

						unexpected behavior.”);

					return getDefault();

				}

				@Override

				public int getPersistenceType() {

					return TopComponent.PERSISTENCE_ALWAYS;

				}

				@Override

				public void componentOpened() {

					// TODO add custom code on component opening

				}

				@Override

				public void componentClosed() {

					// TODO add custom code on component closing

				}

				void writeProperties(java.util.Properties p) {

					// better to version settings since initial version

					as advocated at

					// http://wiki.apidesign.org/wiki/PropertyFiles

					p.setProperty(“version”, “1.0″);

					// TODO store your settings

				}

				Object readProperties(java.util.Properties p) {

					if (instance == null) {

						instance = this;

					}

					instance.readPropertiesImpl(p);

					return instance;

				}

				private void readPropertiesImpl(java.util.Properties p) {

					String version = p.getProperty(“version”);

					// TODO read your settings according to their version

				}

				@Override

				protected String preferredID() {

					return PREFERRED_ID;

				}

			}

As expected, the class TaskEditorTopComponent extends the TopComponent class.

Let’s look at it more closely:

• For efficient resource usage, the generated TopComponent is implemented
  as a singleton. A private constructor prohibits its incorrect usage from
  outside by disallowing direct instantiation of the class. The static attribute
  instance holds the only instance in existence. The static method getDefault
  creates and returns this instance if necessary on demand. Typically,
  getDefault should never be called directly. Instead of this, you should use
  findInstance, which delegates to getDefault if necessary. findInstance
  tries to retrieve the instance using the Window Manager and the ID of the
  TopComponent before falling back to the singleton instance. This ensures the
  correct usage of persistent information.


• The constructor creates the component tree for the TaskEditorTopComponent
  by calling the method init Components(). This method contains only code
  generated via the NetBeans “Matisse” Form Builder and is read-only in the
  NetBeans Java editor. You can change the code in this method using the
  Form Builder’s Property Sheet, as will be shown later.


• The static property PreferredID holds the TopComponent ID used for
  identification of the TopComponent. As indicated by its name, the ID can
  be changed by the Window System, if name clashes occur. The ID is used
  throughout all the configuration files.


• The methods comp onentOpened() and componentClosed() are part of the
  lifecycle of the TopComponent.


• You learn about the method getPersistenceType() later, in the section
  about the persistence of TopComponents.

	What does the Java code do and not do?

	The Java code only defines the visual aspects of the

	TaskEditorTopComponent and manages the singleton instance of this

	component. In no way does the code describe how and where the instance

	is shown. That’s the task of the two XML files, described below.

Two small XML files are created by the wizard. The first is the TopComponent’s
settings file:

	<?xml version=”1.0″ encoding=”UTF-8″?>

	<!DOCTYPE settings PUBLIC “-//NetBeans//DTD Session settings 1.0//EN”

		“http://www.netbeans.org/dtds/sessionsettings-1_0.dtd”>

	<settings version=”1.0″>

		<module name=”com.netbeansrcp.taskeditor” spec=”1.0″/>

		<instanceof class=”org.openide.windows.TopComponent”/>

		<instanceof class=”com.netbeansrcp.taskeditor.

			TaskEditorTopComponent”/>

		<instance class=”com.netbeansrcp.taskeditor.TaskEditorTopComponent”

			method=”getDefault”/>

	</settings>

The settings file describes the persistent instance of the TopComponent. As you can
see, the preceding configuration describes that the TopComponent belongs to the
module TaskEditor in the specification version “1.0″ and that it is an instance of
the types TopComponent and TaskEditorTopComponent. Also described is that the
instance that is created is done so using the method call TaskEditorTopComponent.
getDefault().

	<?xml version=”1.0″ encoding=”UTF-8″?>

	<!DOCTYPE tc-ref PUBLIC “-//NetBeans//DTD Top Component in Mode Properties

		2.0//EN” “http://www.netbeans.org/dtds/tc-ref2_0.dtd”>

	<tc-ref version=”2.0″ >

		<module name=”com.netbeansrcp.taskeditor” spec=”1.0″/>

		<tc-id id=”TaskEditorTopComponent”/>

		<state opened=”true”/>

	</tc-ref>

The WSTCREF (Window System creation file) describes the position of the
TopComponent within the main window. This becomes clearer with the following
file. The other important information in the WSTCREF file is the opened state at
application start.

Typically, you do not have to change these two configuration files by hand. This
is not true for the following file, the layer.xml, which you often need to change
manually, to register new folders and files in the filesystem.

	<?xml version=”1.0″ encoding=”UTF-8″?>

	<!DOCTYPE filesystem PUBLIC “-//NetBeans//DTD Filesystem 1.2//EN” “http://

		www.netbeans.org/dtds/filesystem-1_2.dtd”>

	<filesystem>

		<folder name=”Actions”>

			<folder name=”Window”>

				<file name=”com-netbeansrcp-taskeditor.TaskEditorAction.instance”>

					<attr name=”component”

						methodvalue=”com.netbeansrcp.taskeditor.

						TaskEditorTopComponent.findInstance”/>

					<attr name=”displayName”

						bundlevalue=”com.netbeansrcp.taskeditor.

						Bundle#CTL_TaskEditorAction”/>

					<attr name=”instanceCreate” methodvalue=”org.openide.windows.

						TopComponent.openAction”/>

				</file>

			</folder>

		</folder>

		<folder name=”Menu”>

			<folder name=”Window”>

				<file name=”TaskEditorAction.shadow”>

					<attr name=”originalFile” stringvalue=”Actions/Window/com

						netbeansrcp-taskeditor-TaskEditorAction.instance”/>

				</file>

			</folder>

		</folder>

		<folder name=”Windows2″>

			<folder name=”Components”>

				<file name=”TaskEditorTopComponent.settings”

					url=”TaskEditorTopComponentSettings.xml”/>

			</folder>

			<folder name=”Modes”>

				<folder name=”editor”>

					<file name=”TaskEditorTopComponent.wstcref”

						url=”TaskEditorTopComponentWstcref.xml”/>

				</folder>

			</folder>

		</folder>

	</filesystem>

The layer.xml is integrated into the central registry (also known as the
SystemFileSystem) using the via a registration entry in the module’s manifest
file. The SystemFileSystem is a virtual filesystem for user settings. Each module
can supply a layer file for merging configuration data from the module into the
SystemFileSystem.

The Window System APiand the Actions APireserve a number of folders in the
central registry for holding its configuration data. These folders enable specific
subfolders and files relating to Window System registration to be added to
the filesystem.

• Let’s have a look at the folder Windows2. Windows2 contains a folder
  named Components, which contains a virtual file with the name of the
  TopComponent and the extension .settings. This .settings file redirects
  to the real settings file. It is used to make the configuration known to the
  Window System.


• In addition, the Windows2 folder contains a folder named Modes, which
  contains a folder named editor. Modes represent the possible positions at
  which TopComponents can be shown in the application. The editor folder
  contains a .wstcref file for our TopComponent, which refers to the real
  WSTCREF file. This registers the TopComponent in the mode editor, so it
  shows up where typically editor windows are opened, which is the central
  part of the main window.


• Next, take a look at the folder Actions. It contains a folder named
  Window which contains a file declaring the action opening the
  TaskEditorTopComponent. The name is typically following Java class
  naming conventions with dots replaced by dashes and ending in .instance.
  The declaration of the virtual file itself consists of three critical parts. The
  attribute component describes how to create the component (methodvalue
  declares which method to call). The attribute displayName describes the
  default action name as shown in the example, in menu items. A possible
  declaration is the bundle value which describes the bundle and key to use
  to retrieve the display name. The attribute instanceCreate uses a static
  method call to create a real action to use.


• The folder Menu describes the application main menu. The folder Window
  contains a .shadow file. The attribute originalFile uses the full path in the
  SystemFileSytem to delegate to the original action declaration. As described
  above, .shadow files are used as symbolic links to real-defined virtual files.
  This declaration adds the action to the real menu bar of the application.

As a result, important parts of the Window System APiare not called
programmatically, but are simply used declaratively. Declarative aspects include
configuration and the positioning of windows, as well as the construction of
the menu.

In addition, you discovered that the wizard for creating TopComponents always
creates singleton views. If you would like to change that, you need to adapt the
code created by the wizard. For the time being, it is sufficient to use the singleton
approach, particularly as it is more resource-friendly.

NetBeans Articles

• Create EJB 3.0 project in NetBeans 6.1
• JPA in NetBeans 6.1 by SriHari
• NetBeans Articles
• NetBeans Links
• Buy NetBeans Books from Java Books Store

O n the next page in the wizard, we can select the Server, Java EE Version, and Context Path of our application. In our example we will simply pick the default values.

On the next page of the new project wizard, we can select what frameworks our web application will use.

Unsurprisingly, for JSF applications we need to select the JavaServer Faces framework.

The Visual Web JavaServer Faces framework allows us to quickly build web pages by dragging-and-dropping components from the NetBeans palette into our pages. Although it certainly allows us to develop applications a lot quicker than manually coding, it hides a lot of the “ins” and “outs” of JSF. Having a background in standard JSF development will help us understand what the NetBeans Visual Web functionality does behind the scenes. Visual Web JSF is covered in Chapter 6.

Whe n clicking Finish, the wizard generates a skeleton JSF project for us, consisting of a single JSP file called welcomeJSF.jsp, and a few confi guration fi les: web.xml, faces-config.xml and, if we are using the default bundled GlassFish server, the GlassFish specifi c sun-web.xml fi le is generated as well.

web.xml is the standard confi guration fi le needed for all Java web applications. faces-config.xml is a JSF-specifi c confi guration fi le used to declare JSF-managed beans and navigation rules. sun-web.xml is a GlassFish-specifi c confi guration file that allows us to override the application’s default context root, add security role mappings, and perform several other confi guration tasks.

The generated <i>JSP</i> looks like this:
<%@ page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib prefix="f" uri="http://java.sun.com/<b><i>JSF</i></b>/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/<b><i>JSF</i></b>/html"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%--
This file is an entry point for JavaServer Faces application.
--%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8">
<title><i>JSP</i> Page</title>
</head>
<body>
<f:view>
<h1>
<h:outputText value="JavaServer Faces"/>
</h1>
</f:view>
</body>
</html>

As we can see, a JSF enabled JSP file is a standard JSP fi le using a couple of JSF-specifi c tag libraries. The fi rst tag library, declared in our JSP by the following line:

<%@taglib prefix="f" uri="http://java.sun.com/<b><i>JSF</i></b>/core"%>

is the core JSF tag library, this library includes a number of tags that are independent of the rendering mechanism of the JSF application (recall that JSF can be used for applications other than web applications). By convention, the prefi x f (for faces) is
used for this tag library. The second tag library in the generated JSP, declared by the following line:

<%@taglib prefix="h" uri="http://java.sun.com/<b><i>JSF</i></b>/html"%>

is the JSF HTML tag library. This tag library includes a number of tags that are used to implement HTML specifi c functionality, such as creating HTML forms and input fi elds. By convention, the prefi x h (for HTML) is used for this tag library.

The first JSF tag we see in the generated JSP fi le is the <f:view> tag. When writing a Java web application using JSF, all JSF custom tags must be enclosed inside an <f:view> tag. In addition to JSF-specifi c tags, this tag can contain standard HTML
tags, as well as tags from other tag libraries, such as the JSTL tags discussed in the previous chapter.

The next JSF-specifi c tag we see in the above JSP is <h:outputText>. This tag simply displays the value of its value attribute in the rendered page. The application generated by the new project wizard is a simple, but complete, JSF web application. We can see it in action by right-clicking on our project in the project window and selecting Run. At this point the application server is started (if it wasn’t already running), the application is deployed and the default system browser opens, displaying our application’s welcome page.

Modifying Our JSP to Capture User Data

The g enerated application, of course, is nothing but a starting point for us to create a new application. We will now modify the generated welcomeJSF.jsp fi le to collect some data from the user.

The fi rst thing we need to do is to add an <h:form> tag inside the <f:view> tag. The <h:form> tag is equivalent to the <form> tag in standard HTML pages. We can either type the <h:form> tag directly in the page or drag the JSF Form item from the palette
into the appropriate place in the page markup.

If we choose the second approach, the following window will pop-up:

Selecting Empty Form will generate an empty <h:form> tag which we can use to add our own input fields.

The Form Generated from Entity Class selection is a very nice NetBeans feature that allows us to generate a form that will include input fi elds mapping to all properties in a Java Persistence API (JPA) entity. JPA is covered in detail in Chapter 5.

After adding the <h:form> tag and a number of additional <b><i>JSF</i></b> tags, our page now
looks like this:
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib prefix="f" uri="http://java.sun.com/<b><i>JSF</i></b>/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/<b><i>JSF</i></b>/html"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<link rel="stylesheet" type="text/css"
href="../css/style.css">
<title><i>JSP</i> Page</title>
</head>
<body>
<f:view>
<h1><h:outputText value="JavaServer Faces" /></h1>
<h:form>
<h:panelGrid columns="3"
columnClasses="rightalign,leftalign,leftalign">
<!-- First row begins here -->
<h:outputLabel value="Salutation: "
for="salutation"/>
<h:selectOneMenu id="salutation" label="Salutation"
value="#{RegistrationBean.salutation}" >
<f:selectItem itemLabel="" itemValue=""/>
<f:selectItem itemLabel="Mr." itemValue="MR"/>
<f:selectItem itemLabel="Mrs." itemValue="MRS"/>
<f:selectItem itemLabel="Miss" itemValue="MISS"/>
<f:selectItem itemLabel="Ms" itemValue="MS"/>
<f:selectItem itemLabel="Dr." itemValue="DR"/>
</h:selectOneMenu>
<h:message for="salutation"/>
<!-- Second row begins here -->
<h:outputLabel value="First Name:"
for="firstName"/>
<h:inputText id="firstName" label="First Name"
required="true"
value="#{RegistrationBean.firstName}" />
<h:message for="firstName" />
<!-- Third row begins here -->
<h:outputLabel value="Last Name:" for="lastName"/>
<h:inputText id="lastName" label="Last Name"
required="true"
value="#{RegistrationBean.lastName}" />
<h:message for="lastName" />
<!-- Fourth row begins here -->
<h:outputLabel for="age" value="Age:"/>
<h:inputText id="age" label="Age" size="2"
value="#{RegistrationBean.age}"/>
<h:message for="age"/>
<!-- Fifth row begins here -->
<h:outputLabel value="Email Address:" for="email"/>
<h:inputText id="email" label="Email Address"
required="true"
value="#{RegistrationBean.email}" />
<h:message for="email" />
<!-- Sixth row begins here -->
<h:panelGroup/>
<h:commandButton id="register" value="Register"
action="submit" />
</h:panelGrid>
</h:form>
</f:view>
</body>
</html>

The following screenshot illustrates how our page will be rendered at runtime:

All JSF input fi elds must be inside a <h:form> tag. The <h:panelGrid> helps us to easily align JSF tags in our page. It can be thought of as a grid where other JSF tags will be placed. The columns attribute of the <h:panelGrid> tag indicates how many columns the grid will have, each JSF component inside the <h:panelGrid> component will be placed in an individual cell of the grid, when the number of components matching the value of the columns attribute (three in our example) has been placed inside <h:panelGrid>, a new row is automatically started. Each row in our <h:panelGrid> consists of an <h:outputLabel> tag, an input fi eld, and an <h:message> tag.

The columnClasses attribute of <h:panelGrid> allow us to assign CSS styles to each column inside the panel grid. Its value attribute must consist of a comma separated list of CSS styles (defi ned in a CSS stylesheet). The fi rst style will be applied to the fi rst column, the second style will be applied to the second column, the third style will be applied to the third column, so on and so forth. If our panel grid had more than three columns, then the fourth column would have been styled using the fi rst style in the columnClasses attribute, the fi fth column would have been styled using the second style in the columnClasses attribute, so on and so forth.

The CSS stylesheet for our example is very simple, therefore it is not shown. However, it is part of the code download for this chapter.

If we wish to style rows in an <h:panelGrid>, we can do so with its rowClasses attribute, which works the same way that the columnClasses works for columns. <h:outputLabel>, generates a label for an input fi eld in the form. The value of its for attribute must match the value of the id attribute of the corresponding input field.

<h:message> generates an error message for an input fi eld. The value of its for fi eld must match the value of the id attribute for the corresponding input fi eld. The fi rst row in our grid contains an <h:selectOneMenu>. This tag generates an HTML <select> tag on the rendered page.

Every JSF tag has an id attribute. The value for this attribute must be a string containing a unique identifi er for the tag. If we don’t specify a value for this attribute, one will be generated automatically. It is a good idea to explicitly state the ID of every component, since this ID is used in runtime error messages (affected components are a lot easier to identify if we explicitly set their IDs).

For More Information:

When using <h:label> tags to generate labels for input fi elds, or when using <h:message> tags to generate validation errors, we need to explicitly set the value of the id tag, since we need to specify it as the value of the for attribute of the corresponding <h:label> and <h:message> tags.

Every JSF input tag has a label attribute. This attribute is used to generate validation error messages on the rendered page. If we don’t specify a value for the label attribute, then the fi eld will be identifi ed in the error message by it’s ID. Each JSF input fi eld has a value attribute. In the case of <h:selectOneMenu>, this attribute indicates which of the options in the rendered <select> tag will be selected. The value of this attribute must match the value of the itemValue attribute of one of the nested <f:selectItem> tags. The value of this attribute is usually a value binding expression, which means that the value is read at runtime from a JSF-managed bean. In our example, the value binding expression #{RegistrationBean.salutation} is used. What will happen is, at runtime JSF will look for a managed bean named RegistrationBean, and look for an attribute named salutation on this bean, the getter method for this attribute will be invoked, and its return value will be used to determine the selected value of the rendered HTML <select> tag.

Nested inside the <h:selectOneMenu> there are a number of <f:selectItem> tags. These tags generate HTML <option> tags inside the HTML <select> tag generated by <h:selectOneMenu>. The value of the itemLabel attribute is the value that the user will see, while the value of the itemValue attribute will be the value that will be sent to the server when the form is submitted.

All other rows in our grid contain <h:inputText> tags. This tag generates an HTML input fi eld of type text, which accepts a single line of typed text as input. We explicitly set the id attribute of all of our <h:inputText> fi elds; this allows us to refer to them from the corresponding <h:outputLabel> and <h:message> fi elds. We also set the label attribute for all of our <h:inputText> tags; this results in user friendlier error messages.

Some of our <h:inputText> fi elds require a value. These fi elds have their required attribute set to true, and each JSF input fi eld has a required attribute. If we require the user to enter a value for this attribute, then we need to set this attribute to true. This attribute is optional, and if we don’t explicitly set a value for it, then it defaults to false.

In the last row of our grid, we added an empty <h:panelGroup> tag. The purpose of this tag is to allow adding several tags into a single cell of an <h:panelGrid>. Any tags placed inside this tag are placed inside the same cell of the grid where <h:panelGrid> is placed. In this particular case, all we want to do is to have an ”empty” cell in the grid so that the next tag, <h:commandButton>, is aligned with the input fi elds in the rendered page.

<h:commandButton> is used to submit a form to the server. The value of it’s value attribute is used to generate the text of the rendered button. The value of it’s action attribute is used to determine what page to display after the button is pressed. This
is specifi ed in the navigation rules of the application’s faces-config.xml fi le, which will be covered later in the chapter.

In our example, we are using static navigation. When using JSF static navigation, the value of the action attribute of a command button is hard coded in the JSP markup. An alternate to static navigation is dynamic navigation. When using dynamic navigation, the value of the action attribute of the command button is a value binding expression resolving to a method returning a String in a managed bean. The method may then return different values based on certain conditions. Navigation would proceed to a different page, depending on the value of the method.

As long as it returns a String, the managed bean method executed when using dynamic navigation can contain any logic inside it, and is frequently used to save data in a managed bean into a database.

Both when using static or dynamic navigation, the page to navigate to is defi ned in the application’s faces-config.xml confi guration fi le. Later in this chapter, we will explain how we can graphically confi gure navigation rules using the NetBeans Page
Flow editor.

Creating Our Managed Bean

JSF-managed beans are standard JavaBeans that are used to hold user-entered data in JSF applications. JSF-managed beans need to be declared in the application’s faces-config.xml fi le. NetBeans can help expedite things by automatically adding our managed beans to faces-config.xml.

In order to create a new managed bean, we need to go to File | New, select JavaServer Faces from the category list, and JSF Managed Bean from the file type list.

In the next screen in the wizard, we need to enter a name for our managed bean, as well as a package.

Most default values are sensible and in most cases can be accepted. The only one we should change if necessary is the Scope field.

Managed beans can have different scopes. A scope of request means that the bean is only available in a single HTTP request. Managed beans can also have session scope, in which case they are available in a single user’s HTTP session. A scope of application means that the bean is accessible to all users in the application, across user sessions. Managed beans can also have a scope of none, which means that the managed bean is not stored at any scope, but is created on demand as needed. We should select the appropriate scope for our managed bean. In our particular example, the default request scope will meet our needs.

Af ter fi nishing the wizard, two things happen: a boilerplate version of our managed bean is created in the specifi ed package, and our managed bean is added to the application’s faces-config.xml.

The generated managed bean source simply consists of the class and a public no argument constructor.

package com.ensode.<b><i>JSF</i></b>.managedbeans;
public class RegistrationBean {
/** Creates a new instance of RegistrationBean */
public RegistrationBean() {
}
}
The application's <b><i>faces-config.xml</i></b> contains our managed bean declaration.
<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="1.2"
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-facesconfig_1_2.xsd">

<managed-bean>
<managed-bean-name>
RegistrationBean
</managed-bean-name>
<managed-bean-class>
com.ensode.<b><i>JSF</i></b>.managedbeans.RegistrationBean
</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
</faces-config>

The value of the <managed-bean-name> element matches the value we entered in the Class Name fi eld in the wizard. Notice that this value is what we used in the value binding expressions in our page to access the managed bean properties. Although the value we gave the managed bean matches it’s class name, this is not mandatory. The value we entered in the wizard’s Class Name fi eld is also used as the name of the class that was generated by the wizard, as can be seen by the value of the <managed-bean-class> element, which is the fully qualifi ed name of our managed bean class. Unsurprisingly, the package structure matches the value we entered in the Package fi eld in the wizard. Finally, we see the scope we selected in the wizard as the value of the <managed-bean-scope> element.

At this point, we need to modify our managed bean by adding properties that will hold the user-entered values.

Automatic Generation of Getter and Setter Methods: Netbeans can automatically generate getter and setter methods for our
properties. We simply need to click the keyboard shortcut for “insert code”, which defaults to Alt+Insert in Windows and Linux, then select Getters and Setters.

package com.ensode.<b><i>JSF</i></b>.managedbeans;
public class RegistrationBean {
/** Creates a new instance of RegistrationBean */
public RegistrationBean() {
}
private String salutation;
private String firstName;
private String lastName;
private Integer age;
private String email;
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getSalutation() {
return salutation;
}
public void setSalutation(String salutation) {
this.salutation = salutation;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}

No tice that the names of all of the bean’s properties (instance variables) match the names we used in the JSP‘s value binding expressions. These names must match so that JSF knows how to map the bean’s properties to the value binding expressions.

Implementing Navigation

The last thing we need to do before we can test our application is to implement application navigation. For our application we need to create a confi rmation page, then add navigation rules to our JSP page so that the application navigates from the input page to the confi rmation page when the user submits the form.

NetBeans allows us to save some time by allowing us to graphically add navigation rules via the NetBeans Page Flow Editor. To do so, we need to open faces-confi g. xml and click on the PageFlow button in the toolbar above the fi le. In our particular case we haven’t yet created the confi rmation page we wish to navigate to. This is not a problem, since it can be created “on demand” by NetBeans by right-clicking on the PageFlow editor and selecting New File from the resulting pop-up menu.

At this point the standard New JSP File wizard appears. We enter confirmation. jsp as the name of the new JSP. The new page is automatically created and added to the page fl ow editor.

We can graphically connect the two pages by clicking on the connector to the right of welcomeJSF.jsp and dragging it to confi rmation.jsp.

Doing so generates a navigation case from welcomeJSF.jsp to confi rmation.jsp. As we can see, the navigation case is given a default outcome name of case1. We need to modify this to be the value of the action attribute of the <h:commandButton> in welcomeJSF.jsp.

To do this, we simply double-click on the text representing the navigation case outcome name, then replace it with the appropriate value.

At this point, the navigation case name is updated with the value we entered.

If we had been using dynamic navigation (and, of course, if there were more than two JSP pages in the application), we would simply drag the connector from welcomeJSF. jsp to another page to create a different navigation case based on the value of the managed bean method executed when clicking the page’s command button.

The NetBeans PageFlow editor updates our application’s faces-config.xml behind the scenes. It adds a <navigation-rule> element to it.

<navigation-rule>
<from-view-id>/welcome<b><i>JSF</i></b>.jsp</from-view-id>
<navigation-case>
<from-outcome>submit</from-outcome>
<to-view-id>/confirmation.jsp</to-view-id>
</navigation-case>
</navigation-rule>

The <fr om-view-id> element is the name of the JSP originating the navigation. It is the JSP we drag from in the PageFlow editor to create the navigation case. The value of the <to-view-id> element is the destination page. It is generated from the JSP we drag the navigation case to in the PageFlow editor. The value of the <from-outcome> element is the name of the navigation case outcome in the PageFlow editor.

If we had been using dynamic navigation, we would have separate <navigationcase> elements for each possible return value of the managed bean method bound to the page’s command button, the body of the <from-outcome> element of each navigation case would be one possible return value, and the body of the <to-viewid> would be the page we would navigate to for that particular navigation case.

Notice that the value of the <from-view-id> element starts with a forward slash (/). A common mistake when setting up JSF navigation is to forget this initial tag. When this happens, JSF will fail to find the destination JSP and will simply redisplay the page that initiated the navigation. Using NetBean’s PageFlow editor prevents us from making that mistake.

After setting up our navigation case, we now need to modify the generated confirmation.jsp so that it displays the values in our managed bean.

<%@pa ge contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="f" uri="http://java.sun.com/<b><i>JSF</i></b>/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/<b><i>JSF</i></b>/html" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8">
<link rel="stylesheet" type="text/css"
href="../css/style.css">
<title>Confirmation Page</title>
</head>
<body>
<h2>Confirmation Page</h2>
<f:view>
<h:panelGrid columns="2"
columnClasses="rightalign-bold,normal">
<!-- First row begins here -->
<h:outputText value="Salutation: "/>
<h:outputText
value="#{RegistrationBean.salutation}" />
<!-- Second row begins here -->
<h:outputText value="First Name:"/>
<h:outputText value="#{RegistrationBean.firstName}" />
<!-- Third row begins here -->
<h:outputText value="Last Name:"/>
<h:outputText value="#{RegistrationBean.lastName}" />
<!-- Fourth row begins here -->
<h:outputText value="Age:"/>
<h:outputText value="#{RegistrationBean.age}"/>
<!-- Fifth row begins here -->
<h:outputText value="Email Address:"/>
<h:outputText value="#{RegistrationBean.email}" />
</h:panelGrid>
</f:view>
</body>
</html>

As we can see, our confi rmation page is very simple. It consists of a series of <h:outputText> tags containing labels and value binding expressions bound to our managed bean’s properties.

Executing Our Application

We are now ready to execute our JSF application. The easiest way to do so is to right-click on welcomeJSF.jsp and click on Run File in the resulting pop-up menu, or, if our application is set as the main project, we can click directly to the “Run” icon in the tool bar at the top of the IDE.

At this point GlassFish (or whatever application server we are using for our project) will start automatically, if it hadn’t been started already, the default browser will open and it will automatically be directed to our page’s URL.

After entering some data on the page, it should look something like the following screenshot.

When we click on the Register button, our RegistrationBean managed bean is populated with the values we entered into the page. Each property in the fi eld will be populated according to the value binding expression in each input field.

At this point JSF navigation “kicks-in”, and we are taken to the Confi rmation Page.

The values displayed in the confi rmation page are taken from our managed bean, confi rming that the bean’s properties were populated correctly.

JSF Validation

Earlier i n this chapter we discussed how the required attribute for JSF input fi elds allows us to easily make input fields mandatory.

If a user attempts to submit a form with one or more required fi elds missing, an error message is automatically generated.

The error message is generated by the <h:message> tag corresponding to the invalid fi eld. The string First Name in the error message corresponds to the value of the label attribute for the fi eld. Had we omitted the label attribute, the value of the fi elds id attribute would have been shown instead. As we can see, the required attribute makes it very easy to implement mandatory fi eld functionality in our application.

Recall that the age fi eld is bound to a property of type Integer in our managed bean. If a user enters a value that is not a valid integer into this fi eld, a validation error is automatically generated.

Of course, a negative age wouldn’t make much sense, however, our application validates that user input is a valid integer with essentially no effort on our part. The email address input fi eld of our page is bound to a property of type String in our managed bean. As such, there is no built-in validation to make sure that the user enters a valid email address. In cases like this, we need to write our own custom JSF validators.

Custom JSF validators must implement the javax.faces.validator.Validator interface. This interface contains a single method named validate(). This method takes three parameters: an instance of javax.faces.context.FacesContext, an instance of javax.faces.component.UIComponent containing the JSF component we are validating, and an instance of java.lang.Object containing the user entered value for the component. The following example illustrates a typical custom validator.

package com.ensode.<b><i>JSF</i></b>.validators;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.component.html.HtmlInputText;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
public class EmailValidator implements Validator {
public void validate(FacesContext facesContext,
UIComponent uIComponent, Object value) throws
ValidatorException {
Pattern pattern = Pattern.compile("\\w+@\\w+\\.\\w+");
Matcher matcher = pattern.matcher(
(CharSequence) value);
HtmlInputText htmlInputText = (HtmlInputText) uIComponent;
String label;
if (htmlInputText.getLabel() == null ||
htmlInputText.getLabel().trim().equals("")) {
label = htmlInputText.getId();
} else {
label = htmlInputText.getLabel();
}
if (!matcher.matches()) {
FacesMessage facesMessage =
new FacesMessage(label +
": not a valid email address");
throw new ValidatorException(facesMessage);
}
}
}

In our example, the validate() method does a regular expression match against the value of the JSF component we are validating. If the value matches the expression, validation succeeds, otherwise, validation fails and an instance of javax.faces. validator.ValidatorException is thrown.

The primary purpose of our custom validator is to illustrate how to write custom JSF validations, and not to create a foolproof email address validator. There may be valid email addresses that don’t validate using our validator..

The constructor of ValidatorException takes an instance of javax.faces. application.FacesMessage as a parameter. This object is used to display the error message on the page when validation fails. The message to display is passed as a String to the constructor of FacesMessage. In our example, if the label attribute of the component is not null nor empty, we use it as part of the error message,
otherwise we use the value of the component’s id attribute. This behavior follows the pattern established by standard JSF validators.

Before we can use our custom validator in our pages, we need to declare it in the application’s faces-config.xml confi guration fi le. To do so, we need to add a <validator> element just before the closing </faces-config> element.

<validator>
<validator-id>emailValidator</validator-id>
<validator-class>
com.ensode.<b><i>JSF</i></b>.validators.EmailValidator
</validator-class>
</validator>

The body of the <validator-id> sub element must contain a unique identifi er for our validator. The value of the <validator-class> element must contain the fully qualifi ed name of our validator class.

Once we add our validator to the application’s faces-config.xml, we are ready to use it in our pages.

In our particular case, we need to modify the email fi eld to use our custom validator. <h:inputText id=”email” label=”Email Address”
required=”true” value=”#{RegistrationBean.email}”> <f:validator validatorId=”emailValidator”/> </h:inputText>

All we need to do is nest an <f:validator> tag inside the input fi eld we wish to have validated using our custom validator. The value of the validatorId attribute of <f:validator> must match the value of the body of the <validator-id> element in faces-config.xml.

At this point we are ready to test our custom validator.

When entering an invalid email address into the email address input fi eld and submitting the form, our custom validator logic was executed and the String we passed as a parameter to FacesMessage in our validator() method is shown as the error text by the <h:message> tag for the fi eld.

Displaying Tabular Data

JavaServer Faces includes the <h:dataTable> tag that makes it easy to iterate through an array or collection of objects. With NetBeans, a data table tag can be added to a page by simply dragging the JSF Data Table item from the NetBeans palette into our page. In order to demonstrate the usage of this tag, let’s create a new Web Application project, and add a new JSP named registrationlist.jsp to it.

After dragging the JSF Data Table item into the appropriate location in our registrationlist.jsp page, the following window pops up.

We can either select to create an Empty Table or a Table Generated from an Entity Class.

An Entity Class refers to a Java Persistence API (JPA) entity. We will discuss JPA in detail in Chapter 5 Interacting With Databases through the Java Persistence API.

Selecting to create an empty table generates the following markup in our page:

Selecting to create an empty table generates the following markup in our page:

<h:form>
<h:dataTable value="#{arrayOrCollectionOf}"
var="item">
</h:dataTable>
</h:form>

Notice that NetBeans automatically wraps the generated <h:dataTable> tag in an <h:form> tag. The <h:form> tag is necessary if we plan to have any input fi elds in our table. Since this is not the case in our example, we can safely delete it. The value of the value attribute of <h:dataTable> typically resolves to an array or collection of objects. NetBeans places the placeholder value binding expression #{arrayOrCollectionOf} as its value; we must replace this with a value binding expression resolving to one of the appropriate types.

The value of the var attribute of <h:dataTable> is used to refer to the current element in the table. As we iterate through the elements of the array or collection from the value attribute, we can use the value of the item attribute to refer to the current element in the array or collection.

We need to add a <h:column> tag inside the <h:dataTable> tag for each column we wish to add to the table. The following example illustrates typical usage of <h:dataTable> and <h:column>.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="f" uri="http://java.sun.com/<b><i>JSF</i></b>/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/<b><i>JSF</i></b>/html" %>
<html>
<head>
<meta http-equiv="Content-Type"
content="text/html; charset=UTF-8">
<title><i>JSP</i> Page</title>
</head>
<body>
<f:view>
<h:form>
<h:dataTable
value=
"#{RegistrationListController.registrationBeanList}"
var="item" border="1" cellspacing="0"
cellpadding="5">
<h:column>
<f:facet name="header">
<h:outputText value="Salutation"/>
</f:facet>
<h:outputText value="#{item.salutation}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="First Name"/>
</f:facet>
<h:outputText value="#{item.firstName}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Last Name"/>
</f:facet>
<h:outputText value="#{item.lastName}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Age"/>
</f:facet>
<h:outputText value="#{item.age}"/>
</h:column>
</h:dataTable>
</h:form>
</f:view>
</body>
</html>

In this example, we will be iterating through a collection of RegistrationBean objects. The objects will be stored as a property named registrationBeanList of type java.util.List in a managed bean called RegistrationListController, therefore we set the value of the value attribute of <h:dataTable> to #{RegistrationListController.registrationBeanList}.

NetBeans creates a sensible value for the var attribute, therefore we leave it as is. <h:dataTable> contains a few attributes that allow us to control the look of the generated table. These attributes are identical to attributes in a standard HTML table. In our example, we set a border of 1 pixel in the table by setting the value of the border attribute to 1. We set the spacing between table cells to zero by setting the cellspacing attribute to 0. We also set the spacing (padding) inside table cells to 5 pixels by setting the cellpadding attribute to 5.

Since our table will have four columns, we need to add four nested <h:column> tags into our data table (one for each column).

Noti ce each <h:column> tag has a nested <f:facet> tag. JSF tags might define one or more facets. Facets are components that are rendered differently from other components in the parent component. Each facet must have a unique name for each parent component. <h:column> defi nes a facet with a name of header, this facet will be rendered as the header of the generated table. To render a facet inside a JSF component, the <f:facet> tag is used. In our example we give our facet the name of header by assigning this value to its name property. At runtime, JSF renders the tag inside <f:facet> as the header of the column rendered by the facet’s parent <h:column> tag. Each <f:facet> tag must have a single child tag, which can be any HTML JSF tag.

Add ing Multiple Child Components to a Facet: Although the <f:facet> tag only accepts a single child component, we can add multiple components to it by nesting them inside an <f:panelGroup> tag.

Although not shown in the example, <h:column> also defi nes a facet with a name of footer that can be used to render a footer for the column. We simply would add a second facet named footer inside our <h:column> tag. Next we add the tags that will be displayed as a single cell for the particular column. We can access the current item in the collection or array. We will be iterating, by using the value of the var attribute of <h:dataTable> (item, in our particular example).

In our example we simply display the values for a single property or each item, however any JSF component can be placed inside <h:column>.Before we can deploy our application and see the above page in action, we need to create the RegistrationListController managed bean.

Recall that the easiest way to create JSF managed beans is by going to File | New, selecting the JavaServer Faces category, and JSF Managed Bean as the fi le type. This procedure is covered in detail earlier in this chapter.

Our managed bean is shown next:

package com.ensode.<b><i>JSF</i></b>;
import java.util.ArrayList;
import java.util.List;
public class RegistrationListController {
private List<RegistrationBean> registrationBeanList;
public RegistrationListController() {
}
public String populateList() {
registrationBeanList = new
ArrayList<RegistrationBean>();
registrationBeanList.add(populateBean(
"MS", "Carol", "Jones", 35));
registrationBeanList.add(populateBean(
"MRS", "Glenda", "Murphy", 39));
registrationBeanList.add(populateBean(
"MISS", "Stacy", "Clark", 36));
registrationBeanList.add(populateBean(
"MR", "James", "Fox", 40));
registrationBeanList.add(populateBean(
"DR", "Henry", "Bennett", 53));
return "success";
}
public List<RegistrationBean> getRegistrationBeanList() {
return registrationBeanList;
}
public void setRegistrationBeanList(
List<RegistrationBean> registrationBeanList) {
this.registrationBeanList = registrationBeanList;
}
private RegistrationBean populateBean(String salutation,
String firstName, String lastName, Integer age) {
RegistrationBean registrationBean;
registrationBean = new RegistrationBean();
registrationBean.setSalutation(salutation);
registrationBean.setFirstName(firstName);
registrationBean.setLastName(lastName);
registrationBean.setAge(age);
return registrationBean;
}
}

Notice that the bean has a property named registrationBeanList of type java.util.List. This is the property we used as the value of the value property in the <h:dataTable> tag in the page above.

The bean’s populateList() method will be called from another JSP via dynamic navigation. This method populates the registrationBeanList property in the bean.

A real application would more than likely retrieve this information from a relational database. To keep our example simple we are simply populating the bean from new instances of RegistrationBean we create on the fly.

Now we need to modify the JSP that will be invoked initially. When creating the project, NetBeans automatically sets it up so that a JSP called welcomeJSF.jsp will be invoked when we point the browser to our application’s URL. We need to modify this JSP so that it will invoke the populateList() method of our RegistrationBeanList managed bean when navigating to the page we wrote earlier.

<f:view>
<h:form>
<h:commandLink value="Populate List"
action="#{RegistrationListController.populateList}" />
</h:form>
</f:view>

For brevity, we are only showing the relevant parts of the JSP. Our JSP will have an <h:commandLink> tag used for navigation. <h:commandLink> is functionally equivalent to <h:commandButton>, the main difference is that it is rendered as a link as opposed to a button. The value of the value attribute of <h:commandLink> is used to render the link text; its action attribute is used for navigation. In this case we are using dynamic navigation. When using dynamic navigation, a value binding expression is used as the value of the action attribute. This value binding expression must resolve to a method that returns a String.

The method must take no arguments. When using dynamic navigation, the method that the value binding expression resolves to may return different strings depending on its logic. We can have a page navigate to different pages depending on the value returned by this method. To do this we would have to add a <navigation-case> element for each possible value that the method may return.

In our example, the populateList() method of the RegistrationListController managed bean is invoked when a user clicks on the link. This method populates the list that we will iterate through and returns the value of success. Before we deploy our application, we need to defi ne the navigation between our two pages. Normally this is done by manually editing faces-confi g.xml. However,
when using NetBeans, it can be done graphically in the NetBeans PageFlow editor as explained earlier in this chapter.

The above screenshot shows the PageFlow editor after connecting the initial page containing the <h:commandLink> that initiates navigation to the page that iterates through the list of RegistrationBean instances, and after changing the default navigation case to success. Notice that the text in the navigation case matches the return value of the populateList() method in the RegistrationListController method. This is how the navigation case is linked to the method’s return value.

At this point we are ready to test our application. We can execute the initial welcomeJSF.jsp page by right-clicking on it and selecting Run File.

At thi s point, the application server is started (if it hadn’t been started previously), the application is deployed, and a browser window opens displaying the page.

Here we can see the link that was generated by the <h:commandLink> tag in our JSP. Clicking on that link results in executing the populateList() method in the RegistrationListController managed bean and navigating to the JSP containing the <h:dataTable> tag.

Here we can see the table generated by <h:dataTable>, the headers (Salutation, First Name, Last Name, and Age) are generated by the <f:facet> tags inside each <h:column>. While iterating through the collection of RegistrationBean objects in the registrationBeanList property of the RegistrationListController managed bean, each cell in each row displays the property corresponding to the

<c:outputText> tag inside each <c:column> tag in the table.

Summary

In this chapter we saw how NetBeans can help us easily create new JSF projects by automatically adding all required libraries and confi guration fi les. We also saw how we can create JSF forms for data input and data tables for displaying tabular data by simply dragging and dropping icons from the NetBeans palette into our page.

Additionally, we saw how NetBeans can simplify and signifi cantly speed up development of JSF applications by automatically adding managed bean defi nitions to the application’s <faces-config.xml> confi guration fi le, and by allowing us to graphically defi ne navigation rules by taking advantage of the NetBeans PageFlow editor.

To download the Spring Frame work click on “Download” link. Then select “spring-framework-2.5.1-with-dependencies.zip” link. This download contains all the dependencies required to run the spring framework. Save the downloaded file onto your favorite directory. Now extract the downloaded file (spring-framework-2.5.1-with-dependencies.zip) into your favorite directory.

The dist directory of the spring framework contains the spring modules (modules directory) library files. We are mostly concern with these jar files. We will copy these jar files later into our development environment. These jar files are:

• spring-aop.jar
• spring-beans.jar
• spring-context.jar
• spring-context-support.jar
• spring-core.jar
• spring-jdbc.jar
• spring-jms.jar
• spring-orm.jar
• spring-test.jar
• spring-tx.jar
• spring-web.jar
• spring-webmvc.jar
• spring-webmvc-portlet.jar
• spring-webmvc-struts.jar

3. Configure web.xml

Go to the ‘springdemo/WEB-INF’ directory. Modify the minimal ‘web.xml’ file to suit our needs. We define a DispatcherServlet that is going to control where all our request are routed based on information we will enter at a later point. It also has a standard servlet-mapping entry that maps to the url patterns that we will be using. Let any url with an ‘.htm’ extension be routed to the ‘springdemo’ dispatcher.

Code:

<context-param>
		 <param-name>contextConfigLocation</param-name>
		 <param-value>/WEB-INF/springDemo-servlet.xml</param-value>
	 </context-param>

	 <servlet>
		<servlet-name>context</servlet-name>
		<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	 </servlet>

	 <servlet>
		<servlet-name>springDemo</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	 </servlet>

	 <servlet-mapping>
		<servlet-name>springDemo</servlet-name>
		<url-pattern>*.htm<url-pattern>
	 </servlet-mapping>

Next, create a file called ‘springdemo-servlet.xml’ in the springdemo/WEB-INF directory. This is the file where definitions used by the DispatcherServlet should be entered. It is named based on the servlet-name from web.xml with ‘-servlet’ appended. This is a standard naming convention used in the Spring Framework.

4. Copy jars to “WEB-INF/lib”

Then, from the Spring distribution, copy spring.jar (spring-framework-2.5.1/dist/spring.jar) to the new WEB-INF/lib directory. Also copy commons-logging jars to the WEB-INF/lib directory (spring-framework-2.5.1/lib/jakarta-commons/commons-logging.jar). These jars will be deployed to the server and they are also used during the build process.

5. Configuration of database

Download “hibernate 3.0″ jar from http://www.hibernate.org/ and add the jar to the WEB-INF/lib directory. Add “mysql-connector-java-5.0.3-bin” to the WEB-INF/lib directory. (optional step if you are not having Netbeans 6 and above version installed in you system)

6. Create database and tables in MySQL

• Create database by name “springdemo”.

• Create a table by name “user” under “springdemo” database.

“user” table consists of the following fields:

1. USER_ID integer
2. FIRST_NAME varchar(45)
3. LAST_NAME varchar(45)
4. COMPANY varchar(45)
5. COMMENTS varchar(200)

Since we are using hibernate we have to create a OR mapping file. The mapping file for “user” is created as an xml file by name “User.hbm” under com.simpleweb.user.bean directory under Source Packages directory.

Code:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
 <class name="com.simpleweb.user.bean.User" table="user" lazy="false" >
	 <id name="userId" column="USER_ID" type="java.lang.Integer">
		 <generator/>
	 </id>
	 <property name="firstName" column="FIRST_NAME" type="java.lang.String" />
	 <property name="lastName" column="LAST_NAME" type="java.lang.String" />
	 <property name="company" column="COMPANY" type="java.lang.String" />
	 <property name="comments" column="COMMENTS" type="java.lang.String" />
 </class>
</hibernate-mapping>

Configure database configurations by adding the following code in “springdemo-servlet.xml”

Code:

<!-- DataSource Property -->
<bean id="userDataSource">
	 <property name="driverClassName"><value>com.mysql.jdbc.Driver</value>
	 </property><property name="url"><value>jdbc:mysql:///springdemo</value>
	 </property><property name="username"><value>root</value></property>
	 <property name="password"><value>mysql</value></property>
</bean>

 <!-- Database Property -->
<bean id="userHibernateProperties">
	 <property name="properties">
		 <props>
			 <prop key="hibernate.hbm2ddl.auto">update</prop>
			 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.query.substitutions">true 'T', false 'F'</prop>
			 <prop key="hibernate.show_sql">true</prop>
			 <prop key="hibernate.c3p0.minPoolSize">5</prop>
			 <prop key="hibernate.c3p0.maxPoolSize">20</prop>
			 <prop key="hibernate.c3p0.timeout">600</prop>
			 <prop key="hibernate.c3p0.max_statement">50</prop>
			 <prop key="hibernate.c3p0.testConnectionOnCheckout">false</prop>
		 </props>
	 </property>
</bean>

   <!-- Hibernate SessionFactory -->
<bean id="userSessionFactory">
	 <property name="dataSource"><ref local="userDataSource"/></property>
	 <property name="hibernateProperties"><ref bean="userHibernateProperties" /></property>

	 <!--  OR mapping files. -->
	 <property name="mappingResources">
		 <list>
			 <value>com/simpleweb/user/hibernate/User.hbm.xml</value>
		 </list>
	 </property>
</bean>

7. Modify index.jsp

Open the index.jsp in WEB-INF folder and do the following changes in the code:

Code:

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>User Registration</title>
    </head>
    <body>
        <jsp:forward page="addedituser.htm"/>
    </body>
</html>

8. Creating the Controller

Create your Controller and name as AddEditUserController.java and place it in the springdemo/source packages/ directory.

Code:

	package com.simpleweb.user.controller;

import org.springframework.web.servlet.mvc.Controller;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

public class AddEditUserController implements Controller {

 }

This is as basic a Controller as you can use. We will be expanding this later on, and we will also later on extend some provided abstract base implementations. The Controller handles the request and returns a ModelAndView.

Now, add a bean entry named addEditUserController in springdemo-servlet.xml and make the class AddEditUserController. This defines the controller that our application will be using. We also need to add a URL mapping so the DispatcherServlet knows which controller should be invoked for different URL’s.

Code:

<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

 <!--
   - Application context definition for "springdemo" DispatcherServlet.
   -->

 <beans>
     <bean id="addEditUserController"/>

     <bean id="urlMapping">
         <property name="mappings">
             <props>
                 <prop key ="/addedituser.htm">addEditUserController</prop>
             </props>
         </property>
     </bean>
 </beans>

9. Decouple the view and controller

Right now the controller specifies the full path of the view, which creates an unnecessary dependency between the controller and the view. Ideally we would like to map to the view using a logical name, allowing us to switch the view without having to change the controller. You can set this mapping in a properties file if you like using a ResourceBundleViewResolver and a SimpleUrlHandlerMapping class. If your mapping needs are simple it is easier to just set a prefix and a suffix on the InternalResourceViewResolver. The latter approach is the one that we will implement now, so modify the springapp-servlet.xml and include this viewResolver entry. We have elected to use a JstlView which will enable us to use JSTL.

Add the following to your existing “springdemo-servlet.xml”

Code:

<bean id="viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
	 <property name="viewClass"><value>org.springframework.web.servlet.view.JstlView</value></property>
	 <property name ="prefix"><value>/com/simpleweb/user/pages/</value></property>
	 <property name ="suffix"><value>.jsp</value></property>
</bean>

So now I can remove the prefix and suffix from the view name in the controller.

10. Add some classes for business logic

We would like to add a little bit of business logic in form of a User class and a class that will manage all the users. In order to separate the web dependent logic from the business logic I will create separate packages for the Java source com.simpleweb.user.controller, com.simpleweb.user.bean, com.simpleweb.user.services and com.simpleweb.user.dao. The User class is implemented as a JavaBean and it has the default constructor (automatically provided if we don’t specify any constructors) and getters and setters for the instance variables userId, firstName, lastName, company and comments. I also make it Serializable to pass this class between different application layers.

Code:

package com.simpleweb.user.bean;

import java.io.Serializable;

public class User implements Serializable {

	/** Creates a new instance of User */
	public User() {
	}

	private Integer userId;
	private String firstName;
	private String lastName;
	private String company;
	private String comments;

	public String getFirstName() {
	return firstName;
	}

	public void setFirstName(String firstName) {
	 this.firstName = firstName;
	}

	public String getLastName() {
	 return lastName;
	}

	public void setLastName(String lastName) {
	 this.lastName = lastName;
	}

	public String getCompany() {
	 return company;
	}

	public void setCompany(String company) {
	 this.company = company;
	}

	public String getComments() {
	 return comments;
	}

	public void setComments(String comments) {
	 this.comments = comments;
	}

	public Integer getUserId() {
	 return userId;
	}

	public void setUserId(Integer userId) {
	 this.userId = userId;
	}
}

Create a “Transfer Object” as UserTO under com.simpleweb.user.bean package.

Code:

package com.simpleweb.user.bean;

import java.io.Serializable;

public class UserTO extends User implements Serializable {

	/** Creates a new instance of UserTO */
	public UserTO() {
	}
}

Now, I modify the above created Controller “AddEditUserController” class as shown below to hold a reference of this “UserTO” object

Code:

package com.simpleweb.user.controller;

import com.simpleweb.user.bean.UserTO;
import com.simpleweb.user.services.UserServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;

public class AddEditUserController extends SimpleFormController {

	/** Creates a new instance of AddEditUserController */
	public AddEditUserController() {
	}

	protected Object formBackingObject(HttpServletRequest request) throws ServletException {
	 UserTO userTO = new UserTO();
	 return userTO;
	}
}

11. Creating a View

Now it is time to create our view. We will use a JSP page that we decided to name user.jsp. We’ll put it in the WebPages directory under com/simpleweb/user/pages directory.

Code:

<%@page contentType="text/html"%>
 <%@page pageEncoding="UTF-8"%>
 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 <%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>User Page</title>
</head>
<body>
<form name="userTO"  method="POST" action="addedituser.htm">
	<table style="width: 500px;"  border="0" align="center">
		<tbody>
			<tr>
				<td colspan="2" style="width: 100px;" align="center"><H3>User Registration</H3></td>
			</tr>
			<tr>
				<td style="width: 100px;" >First Name</td>
				<td >
					<spring:bind path="userTO.firstName">
						<input type="text" name="${status.expression}"  maxlength="50" style="width:128px;" value="<c:out value='${status.value}' escapeXml='true'/>" >
					</spring:bind>
				</td>
			</tr>

			<tr>
				<td style="width: 100px;" >Last Name</td>
				<td >
					<spring:bind path="userTO.lastName">
						<input type="text" name="${status.expression}"  maxlength="50" style="width:128px;" value="<c:out value='${status.value}' escapeXml='true'/>" >
					</spring:bind>
				</td>
			</tr>

			<tr>
				<td style="width: 100px;" >Company</td>
				<td >
					<spring:bind path="userTO.company">
						<input type="text" name="${status.expression}"  maxlength="50" style="width:128px;" value="<c:out value='${status.value}' escapeXml='true'/>" >
					</spring:bind>
				</td>
			</tr>

			<tr>
				<td style="width: 100px;" >Comments</td>
				<td >
					<spring:bind path="userTO.comments">
						<textarea name="${status.expression}" id="comments" style="width:400px;" rows="5"><c:out value='${status.value}' escapeXml='true'/></textarea>
					</spring:bind>
				</td>
			</tr>

			<tr>
				<td colspan="2" align="center">
					<input type="submit" name="submit" value="Submit">
					<input type="reset" name="reset" value="Reset">
				</td>
			</tr>
		</tbody>
	</table>
</form>
</body>
 </html>

This form uses a tag library named “spring” that is provided with the Spring Framework. We have to copy this file from the Spring distribution spring-framework-2.5.1/dist/spring.tld to the springdemo/WEB-INF directory. Now we must also add a <taglib> entry to web.xml.

Code:

<taglib>
	<taglib-uri>/spring</taglib-uri>
	<taglib-location>/WEB-INF/spring.tld</taglib-location>
</taglib>

We also have to declare this taglib in a page directive in the jsp file. We declare a form the normal way with a <form> tag and an <input> text field and a submit button.

When the user enters record information it has to be handled by the controller and the business logic will be handles by the service object and data by dao layer.

Create “UserServiceImpl.java” under com.simpleweb.user.services package.

Code:

package com.simpleweb.user.services;

public class UserServiceImpl {

	/** Creates a new instance of UserServiceImpl */
	public UserServiceImpl() {
	}

}

Create “UserDAOImpl.java” under com.simpleweb.user.dao package.

Code:

package com.simpleweb.user.dao;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class UserDAOImpl extends HibernateDaoSupport {

	/** Creates a new instance of UserDAOImpl */
	public UserDAOImpl() {
	}
}

Add the following code as shown below to “AddEditUserController.java”:

Code:

public ModelAndView onSubmit(Object command) throws Exception{
	try {
		UserTO userTO = (UserTO) command;
		userService.register(userTO);
		return new ModelAndView(getSuccessView(),"userTO",userTO);
	} catch (Exception e) {
		return new ModelAndView(getSuccessView(),"error",e.toString());
	}
 }

 private UserServiceImpl userService;

 public UserServiceImpl getUserService() {
	 return userService;
 }

 public void setUserService(UserServiceImpl userService) {
	 this.userService = userService;
 }

“OnSubmit()” handles the fom submission by retrieving the details from the form and sent to service layer and inturn to data layer for persistence.

Configure “UserDAOImpl.java” and “UserServiceImpl.java” in “springdemo-servlet.xml” as shown below:

Code:

<bean id="userDAO">
	<property name="sessionFactory" ref="userSessionFactory" />
</bean>

<bean id="userService">
	<property name="userDAO" ref="userDAO" />
</bean>

Add the following code as shown below to “UserServiceImpl.java”:

Code:

private UserDAOImpl userDAO;

public void register(UserTO userTO) {

	try {
		User user = new User();
		BeanUtils.copyProperties(userTO, user);
		userDAO.register(user);

	} catch (Exception exp) {
		hrow new RuntimeException(exp.toString());
	}
}

public UserDAOImpl getUserDAO() {
	return userDAO;
}

public void setUserDAO(UserDAOImpl userDAO) {
	this.userDAO = userDAO;
}

Add the following code as shown below to “UserDAOImpl.java”:

Code:

public void register(User user) {
	try {
		getHibernateTemplate().save(user);
	} catch (Exception e) {
		throw new RuntimeException(e.toString());
	}
}

12. Deploying and Running the Project

Whether you are using the GlassFish application server or Tomcat, the process for deploying your project is the same. If you installed GlassFish or Tomcat through the IDE download, your server is already registered in the IDE. If you need to make any changes to server settings, or would like to register a different server with the IDE, choose Tools > Servers from the main menu to open the Server Manager.

To deploy the SpringDemo project to the server:

• From the Projects window, right-click the project node and choose Deploy (If you are using NetBeans 6.0 or 6.1, choose Undeploy and Deploy). The IDE compiles the project, starts the server, then deploys the project to it. You can see any output generated in the Output window. The output should complete with a BUILD SUCCESSFUL message.To check that the application has indeed been deployed to the server, open the Services window (Ctrl-5) and expand the Servers node. All servers that are registered in the IDE are listed here. For GlassFish, expand Applications > Web Applications to view the application. For Tomcat, expand Web Applications to view the SpringDemo application.

To run the application:

• In the Projects window, right-click the SpringDemo project node and choose Run. The index.jsp page opens in the IDE’s default browser.

13. Summary

This article concludes, creating a Simple Spring Framework Web application in NetBeans IDE with the database hit using Hibernate.

Note: Netbeans 6 and above has a plugin for various frameworks including Spring framework. With the plug-in, we can avoid boiler plate configuration to get it started.

2. In Server and Settings select the server that you want to use. Here we are going to use GlassFish.

3. Click Next and Finish.

Now its time to create web service form Java class

Creating Web Service project in NetBeans 6.1

• Select the project you created and right click on the project node.
• Choose New > Web Service.

• A New Web service dialog window will open. Give the web service name as “Adder”, give the package name as “ws”. Make sure Create web service from scrach option is selected. Click on finish.

• Web Services node will get created in projects window. Web Services node will contain a Adder node indicating the new web service we created just now. In the editor window area visual designer will open up as shown below.

• Click Add Operation in the visual designer. A dialog box appears where you can define the new operation. In the dialog box enter the name of the service as “Add2Numbers” set the return type to “int”, then add two parameters. name the parameters as “number1″ and “number2″ select the type of both the parameters as “int”. Then click on OK

• The designer now displays the following:

• Now see the source genarated by the IDE by clicking on source tab in the visual designer. The IDE will generate the following source for you.

package ws;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;

/**
*
* @author Sri hari
*/
@WebService()
public class Adder {

/**
 * Web service operation
 */
@WebMethod(operationName = "Add2Numbers")
public int Add2Numbers(@WebParam(name = "number1")
int number1, @WebParam(name = "number2")
int number2) {
	//TODO write your implementation code here:
	return 0;
}

}

• Now change the Add2Numbers method like the following, So that our operation will simply add two numbers and return the result.

/**
 * Web service operation
 */
@WebMethod(operationName = "Add2Numbers")
public int Add2Numbers(@WebParam(name = "number1")
int number1, @WebParam(name = "number2")
int number2) {
	return number1 + number2;
}

• Now we successfully developed a web service wich will add two numbers.

Web Service Deployment in NetBeans 6.1

Now we will deploy the web service like below:

• Right click the project node and select Undeploy and Deploy.
• Once you do that IDE will start the server (GlassFish) and deploys the application to the server.

Web Service Testing in NetBeans 6.1

Now its time to test the web service.

In the IDE’s Projects tab, expand the Web Services node of the project. Right-click the services node, and choose Test Web Service. (Applicable only when deployed using GlassFish). AdderService Web Service Tester page shown below will open in the browser.

Enter the integer values in the textbox of the test page and click on add2Numbers button. This will lead to the result page as shown below.

Summary

In this article you have learnt how to develop a web service using Netbeans 6.1 and deploy the service in GlassFish application server. This article doesnot cover the creation of stubs using Netbeans 6.1 IDE. There are many ways to create stubs to test the web service. So keep learning. This is not the end, Still miles to go.

CREATE DATABASE jpaDB;

GRANT ALL ON jpaDB.* TO jpaDB@"%" IDENTIFIED BY "jpaDB";
GRANT ALL ON jpaDB.* TO jpaDB@"localhost" IDENTIFIED BY "jpaDB";

USE jpaDB;       

Set up a connection to a MySQL database from NetBeans IDE 6.1

NetBeans IDE 6.1 comes with support for the MySQL database. To set up MySql properly in Netbeans IDE 6.1 follow the steps below.

• 1. In Services window expand Databases node. See the screen shot below.

• 2. Right click on MySQL server node. MySQL Server Properties dialog window opens.

• 3. Already host name, port number and admin user name will be pre populated in the dialog. If not then fill in properties and click on ok.

Note: Before you can connect to a MySQL Database Server, you must first ensure that the MySQL Database Server is running on your machine. The MySQL Server node in the Service indicates whether the MySQL Database Server is connected, as shown in the following image.

• 4. After starting the Database Server on your machine, start the MySQL Database Server in the IDE by right-clicking the MySQL Server node and choosing Start.
• 5. Now expand the MySQL server node. We can see the database which we created using command prompt. (We also can create the database using netbeans itself. Since we have created the database already we don’t cover those steps in this artical).

• 6. Now we will connect the database as shown below in the figure. Enter the password for the user if there is one, then click OK to create the new database connection. Click OK again if no schema is required.

• 7. we can see the database appearing in the services window.

Creating Table in MySql 5.0

Now we will create a table and name it as “USER”.
In the services window expand the database (See the figure below)
we created in the previous section. Right click on the table node.
select create table.

Invoking on create table node will result in create table dialog.
This window will halp us in creating the table with ease as shown in the below diagram.

Create a JavaApplication in NetBeans 6.1

Now create a java application in NetBeans IDE. Let us name the application as MyJPAApplication.

Next step is to generate a Entity class which will map to User table.

Select the database created as shown in the below figure.

You can now see the tables available in the database will be listed in the Available Tables menu.
Select the user table and click on Add to move it to Selected tables menu.

Change the class name in the next wizard as UserGenEntity. Then click on Create Persistence Unit button.

In the create persistant unit wizard, change the Table Generation Strategy option to Create.

Now in the final wizard there will not be any information or warning messages shown. Then click on finish.

Once you clicked on finish. you can see the class named UserGenEntity getting generated in the Projects window of the IDE. You can also see the TopLink libraries getting added to the Libraries node as shown below.

Next step is to implement a Manager Class which handles the JPA persistence-context. That means this class is responsible to provide CRUD functionality for your instances and to communicate with your database.
We will name this manager class as UserManager. UserManager code is given in the below listing.

Sample JPA Application

package com.myJpa;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;

/**
 *
 * @author Sri hari
 */
public class UserManager {

    private EntityManager em;

    public UserManager(EntityManagerFactory emf) {
        em = emf.createEntityManager();
    }

    public void createUser(UserGenEntity user) {
        em.getTransaction().begin();
        em.persist(user);
        em.getTransaction().commit();
    }

    public UserGenEntity searchById(Integer id) {
        return em.find(UserGenEntity.class, id);
    }

    public void updateUser(UserGenEntity user) {
        em.getTransaction().begin();
        em.merge(user);
        em.getTransaction().commit();
    }

    public void removeUser(UserGenEntity user) {
        em.getTransaction().begin();
        em.remove(user);
        em.getTransaction().commit();
    }

    public List getAll() {
        Query query = em.createQuery("select a from UserGenEntity a");
        List list = query.getResultList();
        return list;
    }

    public void close() {
        em.close();
    }
}
        

Code List has the following methods:

• createUser — this method is used to create a user in the database.
• searchById — this method is used to search a user by ID.
• updateUser — this method is used to update a user from the table.
• removeUser — this method is used to remove a user from the table.
• getAll — this method is used to get all the users from the table.

Testing the JPA code

Now its time to test the code and see how it works. Before that don’t forget to add the driver for MySQL to your project library.

Testing can be done using JUnit or a simple Java class with main method. Here we will create a simple java class with main method to test our code.

package com.myJpa;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author Sri hari
 */
public class TestJPA {

    private UserManager um;
    private EntityManager em;
    private EntityManagerFactory emf;
    private static final UserGenEntity user1 = new UserGenEntity(1, "Muthu", "Dhanagopal");
    private static final UserGenEntity user2 = new UserGenEntity(2, "Sri", "Hari");

    protected void setUp() throws Exception {
        emf = Persistence.createEntityManagerFactory("MyJPAApplicationPU");
        em = emf.createEntityManager();
        um = new UserManager(emf);
    }

    protected void close() throws Exception {
        um.close();
        em.close();
        emf.close();
    }

    public void test() {
        um.createUser(user1);
        UserGenEntity user = um.searchById(1);
        System.out.println("After creation of user in table");
        System.out.println("Firstname: " + user.getFirstname());
        System.out.println("Lastname: " + user.getLastname());

        user.setFirstname("Muthukumar");
        um.updateUser(user);

        user = um.searchById(1);
        System.out.println("After update.");
        System.out.println("Firstname: " + user.getFirstname());
        System.out.println("Lastname: " + user.getLastname());

        System.out.println("Adding one more record");
        um.createUser(user2);

        List list = um.getAll();
        System.out.println("Number of users: " + list.size());
    }

    public static void main(String args[]) {
        System.out.println("Inside TestJPA main");
        TestJPA testJPA = new TestJPA();
        try {
            testJPA.setUp();
            testJPA.test();
            testJPA.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("End of TestJPA main");
    }
}
        

Result

init:
deps-jar:
compile-single:
run-single:
Inside TestJPA main
[TopLink Info]: 2008.07.27 09:42:50.500--ServerSession(16602326)--TopLink, version: Oracle TopLink Essentials - 2.0.1 (Build b09d-fcs (12/06/2007))
[TopLink Info]: 2008.07.27 09:42:52.253--ServerSession(16602326)--file:/C:/NetBeansProjects/MyJPAApplication/build/classes/-MyJPAApplicationPU login successful
[TopLink Warning]: 2008.07.27 09:42:52.410--ServerSession(16602326)--Exception [TOPLINK-4002] (Oracle TopLink Essentials - 2.0.1 (Build b09d-fcs (12/06/2007))): oracle.toplink.essentials.exceptions.DatabaseException
Internal Exception: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'user' already exists
Error Code: 1050
Call: CREATE TABLE user (ID INTEGER NOT NULL, FIRSTNAME VARCHAR(255), LASTNAME VARCHAR(255), PRIMARY KEY (ID))
Query: DataModifyQuery()
After creation of user in table
Firstname: Muthu
Lastname: Dhanagopal
After update.
Firstname: Muthukumar
Lastname: Dhanagopal
Adding one more record
Number of users: 2
[TopLink Info]: 2008.07.27 09:42:52.864--ServerSession(16602326)--file:/C:/NetBeansProjects/MyJPAApplication/build/classes/-MyJPAApplicationPU logout successful
End of TestJPA main
BUILD SUCCESSFUL (total time: 7 seconds)

Summary

In this article you have learnt how to develop a JPA persistence layer using Java Application. This is not the end, Still miles to go.

Show Full Image

Step 2 : Select Enterprice Project

Show Full Image

Step 3 : Specify Project Name

Show Full Image

Step 4 : Select server and create EJB,WEb modules

Show Full Image

Step 5 : Project is created

Show Full Image