Practical Database Programming With Java

578 Chapter 8 Developing Java Web Applications to Access Databases

Figure 8.19. The running status of the FacultyPage.jsp.

By referring to Figure 8.18, we can get a clear and complete picture about the data storage and transferring between different pages.

Now if you compile and run these three files, FacultyPage.jsp, FacultyQuery.jsp, and FacultyBean.java, you can get the start page shown in Figure 8.19.

Enter a desired faculty name, such as Ying Bai, into the Faculty Name text field, and click on the Select button; the running result is shown in Figure 8.20.

As we mentioned at the beginning of this chapter, Java EE provides a set of powerful tools and supports to Java Web applications to access and manipulate databases. One of the most important components provided by Java EE is the Java bean that works as a separate component to perform database-related operations and business logics. By combining the JavaServer Faces techniques and Java beans, a professional Java Web database application can be divided into two separate parts: the GUIs that are built with JSF tags in JSP are used for data presentations and results displaying, and Java managed beans used for database-related operations and business logics. By dividing a Web application into these two sections, it has greatly reduced the development efforts and complexities in the coding development and organizations of the whole application.

Now let’s take care of using Java beans technology for Java Web applications.

8.1.6 Using Java Beans Technology for Java Web Applications

In recent years, the Java bean technique has been widely applied in Java Web applications. In fact, a Java bean can be considered as an extended Java help class as we discussed in the previous sections, and the main purpose of a Java bean is to handle the JDBCand database-related operations, as well as business logics in a Web application.

8.1 A Historical Review about Java Web Application Development 579

Figure 8.20. The running result of the FacultyPage.jsp.

In fact, Java beans are reusable components, and the main purpose of using Java beans is to separate business logics from the presentations.

Exactly, a Java bean is just an instance of a class.

Once a JavaBean is created and loaded, it can be used by all parts of your applications based on its scope.The so-called scope defined the section or part of you applications can access and use this bean. Generally, there are four popular scopes available to a Java Bean object and the default scope is page scope.

•page scope: The bean is accessible within a JSP page with the <jsp: useBean> tag, or any page’s static include files until the page sends response to the client or forward a request to another page. In other words, as long as the process happened in the current page, the bean can be accessed and used until the process has been transferred to other pages.

•request scope: The bean is accessible from any JSP page as long as the same request is processed in that page until a JSP page sends a response to the client or forward the request to another page. In other words, the bean can be used until a different request has been forwarded or a response for that request has been received, which means that the life time or the scope of that request has been completed.

•session scope: The bean is accessible from any JSP page in the same session as the JSP page that creates the bean. A session can be considered as common place where many JSP pages can exist and share. The JSP page in which you create the Java bean must have a JSP

page directive <%@ page %> with the session = true.

•application scope: The bean can be accessed from any JSP page in the same application as the JSP page that creates the bean. In other words, any JSP page can use the bean as long as that page is included in the application in which the JSP page that creates the bean is included.

580 Chapter 8 Developing Java Web Applications to Access Databases

It is no difference between creating a help class and creating a Java bean class. In fact, the help class FacultyBean.java we created in the last section is exactly a Java bean class.

To use a Java bean, the JSP provide three basic tags for working with beans.

<jsp:useBean id=″bean name″ class=″bean class″ scope = ″page | request | session |application ″/>

The definitions for these three tags are:

1.The bean name is just a given name to refer to the used Java bean. You can use any valid name for this tag.

2.The bean class is a full name of the Java bean class you created. The so-called full name means that you need to use both the bean class’s name and the package’s name in which the bean is located. For example, this bean class should be: mypackage.mybeanclass if the bean class named mybeanclass is located at the package mypackage.

3.The scope indicates the range or the life time the bean can be used. Refer to those four scopes we discussed above to get more detailed information about them.

A very useful JSP directive used for Java bean class is <jsp:setProperty />. The protocol of this directive is:

<jsp:setProperty name = ″id″ property = ″someProperty″ value = ″someValue″ />

Three arguments for this directive are:

1.The id is the bean name as we discussed in step 1 above.

2.The someProeprty is exactly the property’s name defined inside the Java bean class, such as facultyId and facultyName we defined in our FacultyBean.java class in the last section.

3.The someValue is the initialized value assigned to a property in the bean class.

A variant for this tag is the property attribute, which can be replaced by an “*”. What this does is that it accepts all the form parameters and thus reduces the need for writing multiple setProperty tags. The only point to be remembered when you are using this variant is that the form parameters’ names must be the same as those of the bean properties’ names.

An example of using this setProperty tag is:

<jsp:setProperty name=″dbFaculty″ property=″*″ />

In this setProperty tag, the id of the Java bean class is dbFaculty. The * in the property value means that all parameters transferred from another page can be assigned to the associated properties in the Java bean class.

Now let’s modify the FacultyBean.java to make it a Java bean class to replace the help class file FacultyBean.java we built in the last section.

8.1.6.1 Modify the Help Class FacultyBean to Make it a Java Bean Class

First, we need to create a new Java Session Bean class named FacultyBean in the NetBeans IDE. Then, we need to add seven setter() method into this bean class. Your finished Java

8.1 A Historical Review about Java Web Application Development 581

@Stateless

public class FacultyBean { private String facultyID; private String facultyName; private String office; private String title;

private String phone; private String college; private String email;

}

Figure 8.21. The modified help class—now it is a Java bean class.

bean class FacultyBean.java is shown in Figure 8.21. All modified codes have been highlighted in bold.

Let’s have a closer look at this piece of modified codes to see how it works. Starting from step A until step G, seven setter() methods are added into this Java

bean class. All of these setter() methods are used to set up the initial values for seven properties in this bean.

Next, we need to create a new transaction JSP page FacultyBeanQuery.jsp to make it to transfer data between our new starting page FacultyBeanPage.jsp and our Java bean class FacultyBean.java. Basically, this FacultyBeanQuery.jsp file has no significant

582 Chapter 8 Developing Java Web Applications to Access Databases

<%@ page import="java.util.*" %>

<%@ page import="JavaWebHibDBOraclePackage.*" %> <%@ page import="csedept.entity.Faculty" %>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>FacultyBeanQuery Page</title>

</head>

<body>

<h1>This is the FacultyBeanQuery Page</h1>

A<jsp:useBean id="dbFaculty" scope="session" class="JavaWebHibDBOraclePackage.FacultyBean" />

B<jsp:setProperty name="dbFaculty" property="*" /> <%

CString fname = request.getParameter("FacultyNameField");

DList<Faculty> facultyList = dbFaculty.QueryFaculty(fname);

Eresponse.sendRedirect("FacultyBeanPage.jsp");

%>

</body>

</html>

Figure 8.22. The codes for the FacultyBeanQuery.jsp page.

difference with the FacultyQuery.jsp we built in the last section. The only different part is the way to execute the JDBCand database related queries or business logics. In FacultyQuery.jsp file, we called a Java help class FacultyBean.java to do those functions. However, in FacultyBeanQuery.jsp, we will call a modified help class that has been converted to a Java bean FacultyBean.java to perform these functions.

The codes of the FacultyBeanQuery.jsp file are shown in Figure 8.22. Now let’s have a closer look at this piece of codes to see how it works.

Some system-related or user-related packages are imported at the beginning of this page. The JSP directive <%@ page /> is used to convert those packages and embedded into this page. Three packages are imported here: the java.util.* package contains the List class, the JavaWebHibDBOraclePackage contains our Java bean class FacultyBean, and the csedept.entity.Faculty is a Hibernate class mapping for the Faculty table in our sample database CSE_DEPT.

A.The Java bean class is declared with the JSP tag <jsp:useBean /> with three tags we discussed at the beginning of this section. The referenced name for this bean is dbFaculty, which is assigned to the id of the bean. The scope of this bean is session. and the full name of this bean class is JavaWebHibDBOraclePackage.FacultyBean.

B.The setProperty tag is used to set up all parameters passed from the FacultyBeanPage. jsp page to the associated properties in the bean class FacultyBean.

C.The Java codes are starting from a JSP tag, and the faculty name parameter is retrieved by using the getParanmeter() method and assigned to a local String variable fname.

D.The main bean method QueryFaculty() is executed to query a faculty record based on the retrieved faculty name from the FacultyBeanPage.jsp page. The result is assigned to a local List variable. In fact, this result is not important in this application since the columns in the query result have been assigned to the associated properties in the bean class, and later on we can pick up those columns by calling the getter() methods in the bean class.

E.Since we want to fill those text fields in our starting page FacultyBeanPage.jsp with the queried result, we used the sendRedirect() method to return the process back to that page.

8.1 A Historical Review about Java Web Application Development 583

Figure 8.23. The new starting Web page FacultyBeanPage.jsp.

Now let’s take a look at a new starting page FacultyBeanPage.jsp that will be used to call the transaction JSP page and Java bean to perform the faculty data query and display query result in this page. Because of the complex in building this page with HTML codes, we leave this coding job to our project development stage later.

8.1.6.2 Build a New Starting Web Page FacultyBeanPage

The preview of this page is shown in Figure 8.23.

The difference between this starting page and the starting page FacultyPage.jsp we built in the last section is: in the FcaultyPage.jsp, we used a JSP built-in or implicit object session to transfer data between this page and the help class. However, in the new starting page FacultyBeanPage.jsp, we need to use the properties defined in the Java bean class to do this data transferring jobs.

Exactly, we need to use the Java bean’s getter() method to replace those session. getAttribute() methods embedded in the value tag of each text field to retrieve and display the associated column queried from the Faculty table in our sample database in each text field in this new starting page.

The codes for this new starting page are shown in Figure 8.24. The modified parts have been highlighted in bold.

Let’s have a closer look at this piece of codes to see how it works.

A.A JSP tag that declared to use a Java bean is put in the beginning of this page to indicate that a Java bean will be called to perform JDBCand database-related queries or business logics, and the result will be retrieved and reflected in this starting page.

584 Chapter 8 Developing Java Web Applications to Access Databases

A<jsp:useBean id="dbFaculty" scope="session" class="JavaWebHibDBOraclePackage.FacultyBean" />

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Faculty Query Page</title>

</head>

<body>

<%@page language="java" %>

B<form method=post action=".\FacultyBeanQuery.jsp">

<input name=FacultyNameField maxlength=255 size=24

Cvalue="<%=dbFaculty.getFacultyName() %>" type=text v:shapes="_x0000_s1109">

………

………

</body>

</html>

Figure 8.24. The new starting page FacultyBeanPage.jsp.

B.The next page is changed to FacultyBeanQuery.jsp in the action tag of the form, which means that the page and all data in this starting page will be forwarded to the next page if any submit button is clicked by the user from this page.

C.Starting from step C until step I, the different Java bean’s getter() methods are executed to retrieve the matched columns from the queried result and display them one by one in each associated text field.

From this piece of codes, you can find how easy it is to transfer data between the starting Web page written in either HTML or JSP and Java bean class by using the Java bean’s properties.

From examples discussed above, it can be found that the JSP technology did provide a good communication and data passing ways between the Servlet and client web pages; however, they did not provide a direct binding and mapping between the Web page’s components and the server side codes. This kind of binding and mapping plays more important roles in today’s complicated and multi-tier Web applications.To meet this need, a new technology has been introduced in recent years, which is the JavaServer Faces (JSF) technology.

With this new technology, all Web components can be installed and distributed in a Web page by using the JSF tags. Also, more important, all of these components can be bound to the server side properties and functions using the so-called backing beans or

8.1 A Historical Review about Java Web Application Development 585

Java managed beans. By using a Unified Expression Language (EL) value expression, the value of the property of a mapped or bound Web component can be easily picked up from a backing bean in the server side.

8.1.7 Using JavaServer Faces Technology for Java Web Applications

JavaServer Faces (JSF) provides new techniques and components for building User Interfaces (UI) for server-side applications. In fact, JSF is a server-side technology for developing Web applications with rich user interfaces. Before JavaServer Faces, developers who built Web applications had to rely on building HTML user interface components with Servlets or JSP. This is mainly because HTML user interface components are the lowest common denominator that Web browsers support. One of the defects of using HTML or JSP techniques to build Web applications is that such Web applications do not have rich user interfaces, compared with standalone fat clients, and therefore less functionality and/or poor usability are involved in those Web applications. One of possible solutions is to use Applets to develop rich user interfaces; however, in most cases, Web application developers do not always know whether those Applets are signed or unsigned applets, and whether they can access the local database files or not. This will greatly limit the roles and implementations of Applets in Java Web database applications.

A good solution is to use JavaServer Face technique that provides a set of rich GUI components and can be installed and run in the server side. The GUI components provided by JSF are represented by a collection of component tags. All component tags are defined and stored in the UIComponent class. A model-view-controller (MVC) mode is applied to the JSF technique.

The JSF technology consists of following main components:

•JSF APIs used to represent UI components, manage state, handle events, and validate input. The UI components are represented and implemented using JSF tags. The API has support for internationalization and accessibility.

•A special Servlet class FacesServlet that is located at the server side and works as a controller to handle all JSF-related events.

•JSP pages that contain rich user interface components represented by customer tags and work as views. The GUI of a JSF page is one or more JSP pages that contain JSF component tags.

•Two JSP custom tag libraries used for expressing the JSF user interface (UI) components within a JSP page, and for wiring components to server-side objects. Page authors can easily add UI components to their pages.

•Java bean components used to work as model objects.

•Application configuration resource file faces-config.xml used to define the navigation rules between JSP pages and register the Java backing beans.

•Web deployment descriptor file web.xml used to define the FaceServlet and its mapping.

JavaServer Face technology is basically built based on JavaServer Page and Servlet techniques. It uses JSP pages as the GUI and FacesServlet as the Web container. A highlevel architecture of JSF is shown in Figure 8.25.

586 Chapter 8 Developing Java Web Applications to Access Databases

JSF APP

JSF APP

JSF Tags

Servlet

Figure 8.25. High-level architecture of JSF.

It can be found from Figure 8.25 that a JSF Web application is composed of JSP pages representing the user interface components using the JSF custom tag library and FacesServlet Web container, which can be considered as a part of Servlet class and takes care of the JSF related events.

JSF defines two standard tag libraries (Core and HTML) that you have to declare in your JSP pages with the <%@taglib%> directive. Two tag libraries are:

•html_basic.tld: A JSP custom tag library for building JSF applications that render to an HTML client.

•jsf_core.tld: A JSP custom tag library for representing core actions independent of a particular render kit.

The JSF core library contains tags that do not depend on any markup language, while the JSF HTML library was designed for pages that are viewed in a Web browser. The standard prefixes of the two tag libraries are f for the JSF Core and h for the JSF HTML. All JSF tags must be nested inside a <f:view> element. The <f:view> tag allows the JSF framework to save the state of the UI components as part of the response to a HTTP request.

To use these customer tags to represent JSF components in JSP pages, one needs to indicate them by using the following two taglib directive on the top of each JSF file:

•<%@ taglib uri=“http://java.sun.com/jsf/html” prefix=“h” %>

•<%@ taglib uri=“http://java.sun.com/jsf/core” prefix=“f” %>

The uri is used to indicate the locations of the customer tag libraries.

JavaServer Face (JSF) pages are just regular JSP pages that use the standard JSF tag libraries or other libraries based on the JSF API.When using JSF tag components to build a JavaServer Page, a component tree or a view is created in the server side memory, and this tree will be used by the JSF frameworks to handle the requests coming from the clients and send responses to the clients. Each JSF tag component is mapped to a component class defined in the UIComponent class. In fact, each tag is an instance of the mapped class in the UIComponent.

JSF utilized an MVCarchitecture, which means that it uses Java beans as models to stored application data, and JSF GUI as the view and the Servlet as the controller.

8.1.7.1 The Application Configuration Resource File faces-config.xml

The navigation from one page to another can be done in two ways. One way is directly to use the codes by writing the JSP tag such as <jsp:forward /> or the HTML hyperlink