JAVA 2 PLATFORM ENTERPRISE EDITION
J2EE
Submitted by:
Nimisha Bajwa
Greg Boutain
Letisha Larson
Dragana Lojanica
Gretchen Stoltz
MIS 375
December 18, 2002
Introduction
Java is a language that enhances current Internet and World
Wide Web capabilities. It makes it possible to program for the Internet
by creating applets. Applets are programs that can be embedded into
a Web page. But Java technology is far more than a programming
language for writing applets. It is also being used for writing
standalone applications. With the development of Java 2 SDK and
Enterprise Edition, Java technology is becoming more and more
pervasive in the enterprise arena. Our research is geared toward the
understanding of Java 2 Platform Enterprise Edition, what is it and
some of its components.
First introduced by Sun Microsystems in late 1999, the Java 2
Platform Enterprise Edition (J2EE) defines architecture for developing
complex, distributed enterprise Java applications. J2EE was born in an
effort to align Java technologies and Application Programming
Interfaces (API’s) together in order to develop specific types of
applications. “Java Server technology consists of Java-based
frameworks and API’s that together provide a versatile combination,
capable of building many kinds of server applications that are portable
and scalable” (Introduction to Java Servers). Java’s portability comes
from being able to write programs on the server side only once and
then these programs can be run anywhere. For example, code could
2
be written on laptop computers and then transferred to mainframes to
speed up the development.
One of the strengths of the Java Web Server is the provision of
three-layer container for applications. “The outermost layer is the Java
Server, which contains a service, which surrounds the Servlet API,
which, in turn, surrounds the code for an application” (Woods,
Pekowsky & Snee 4). Java Web Server has a lot of powerful features
such as security, extensibility, easy of configuration and managing,
ability to integrate with the HTTP protocols, and Java Server Pages.
Java Server Pages (JSP) is a scripting capability built on Java
Servlets. “JSPs technology allows Web developers and designers to
rapidly develop and easily maintain, information-rich, dynamic Web
pages that leverage existing business systems” (Dynamically
Generated Web Content). So, before going into JSP, servlets need to
be explained as well as understood.
Servlets
One of the most frequently used J2EE components found on the
World Wide Web today is servlet. Actually, servlets helped make many
Web applications possible. They are platform independent Web
components capable of generating dynamic content. “They provide an
effective mechanism for interaction between the server-based
business logic and the Web-based client” (Ahmed & Umrysh 17 – 18).
Servlets are best used to handle simpler tasks such as checking for
3
valid inputs from the entry fields on a Web page. They are designed
specifically to process Hypertext Transfer Protocol (HTTP) requests
coming from the Web client and pass back a response. Servlets
together with JSP technology provide a very attractive alternative to
other types of dynamic Web programming by offering enhanced
performance, platform independence, separation of logic and content,
and the most important of all, ease of use (Dynamically Generated
Web Content). “A servlet can almost be thought of as an applet that
runs on the server side – without a face” (The Power Behind the
Server).
Java Server Pages
JSP’s are another type of J2EE Web component that have been
evolved from servlet technology. JSPs provide a simplified and fast
way to create Web pages that display dynamically generated content.
With JSP it is much easier for members of a Web team to maintain the
portions of the system that support Web page presentation without
requiring them to be traditional programmers. Using JSP technology
the user interface can be separated from the content generation
therefore enabling designers to change the page layout without
compromising the content. Because of this separation, it is much
easier and faster than ever to build Web applications. JSPs permit Java
code to be embedded within a structured document such as HTML
(Hypertext Markup Language) or XML (eXtensible Markup Language).
4
The current version of JSP has an XML compatible syntax. It uses XML
tags to encapsulate the logic that actually generates the content for
the Web Page. “The application logic can reside in server-based
resources such as Java Beans” (The Power Behind the Server) that can
be accessed with XML tags.
Here is the example that illustrates how Java Server Pages works.
First, if we wanted to write a “Hello World” application that would
include the date the page was generated when printed without Java
Server Pages this is what we would have to write:
“import Java.util.Date;import Java.text.*;import Java.io.*;import Javax.servlet.*;import Javax.servlet.http.*;public class HelloWorldDate extends HttpServlet { public void service (HttpServletRequest req, HttpServletResponse res) throws ServletException,IOException{ //Set header for outputres.setContentType (“text/html”);res.setStatus (res.SC_OK);ServletOutputStream out = res.getOutputStream ( );DateFormat df = DateFormat.getDateTimeInstance ( );out.println (“<HTML>”);out.println (“<HEAD><TITLE>Hello World
Date</TITLE></HEAD>”);out.println (“<BODY>”);out.println (“<H1>Hello World on” + df.format (new Date ( ) ) + “</H1>”);out.println (“</BODY>”);out.println (“</HTML>”);out.close ( ); }}” (Woods, Pekowsky & Snee 104-105).
5
This code is mostly dedicated to printing out HTML statements after
the time and date is added to the application. However, this is a very
lengthy and complex code if only a simple change is required in an
HTML document. Therefore, changes have to be made by
programmers because there is a need to know how to change the
program as well as how to compile it. To write the same code that will
execute the same thing using Java Server Pages is the following:
“%@ import=”Java.util.Date”%><%@ import=”Java.text.*”%><HTML><HEAD><TITLE>Hello World Date</TITLE></HEAD><BODY><% DateFormat df = DateFormat.getDateTimeInstance ( ); %><H1>Hello World on <% out.println (df.format (new Date ( ) ) ); %> </H1></BODY></HTML>” (Woods, Pekowsky & Snee 105).
If we compare the previous two code applications, we can see that the
second one is much more like an HTML file than a program. However,
it does have program-like elements but is much simpler and easier to
write than the first program. “The tedious repetition of out.println
statements is avoided at the expense of encapsulating all Java
statements inside the <% %> brackets” (Woods, Pekowsky & Snee
106).
The next question is how could this JSP file be served to the user
because if we would name this file as .html document it would not
6
work properly as the code would never be compiled nor executed. We
need a translator that would read the HTML and Java statements and
translate them into out.println ( ) statements. This is exactly what the
JSPServlet does. The JSPServlet takes the HTML code outside the <%
%> brackets which enclose Java code and places it inside out.println ( )
statements. Then, it copies the Java code within the brackets into the
file but <% %> brackets are not copied. JSP files have *.JSP
extensions.
Figure 1.1 explains the steps for executing a JSP. First, after the
user requests a JSP, the JSPServlet which acts like a translator looks to
see if the page has been compiled. If it is compiled, the JSPServlet has
to check and see whether it has been changed or not since it was last
compiled. If it has been changed since it was last compiled it is
recompiled and if it does not have to be compiled, as it didn’t change,
it can be executed immediately. Also, if it does not have to be
compiled before it is executed, it takes less time to serve the page.
Because of this, most of the time, the pages will be compiled before
they are requested as to make the response time quite speedy.
Figure 1.1 JSP JSPServlet structure (Woods, Pekowsky & Snee 107).
7
User Requests a JSP
Is the Page Compiled into a Servlet?
No
Yes
No
Yes
A JSP consists of two basic items: template data and JSP
elements. Template data provides the static aspects while on the
other side JSP elements are used for the dynamic aspects of a JSP. JSP
elements represent the portion of the JSP that gets translated and
compiled into a servlet by the JSP compiler. In a sense, JSP elements
are very similar to HTML elements.
There are three types of JSP elements: directive, action, and
scripting elements. Directive elements are very general in nature. It
means that they are not related to any specific request; they just
provide overall information for the translation phase. Using directives
8
Is the JSP Page Unchanged?
Compile a JSP Page into a Servlet
Execute the Servlet
one can tell where the JSP engine is located even before it is
assembled. Also, directives can tell whether there is a session in use
or not as well as how to handle errors in case they occur while running
the JSP. Using directives is very simple; there are only three directives
according to the JSP Syntax Reference (Development of the JSP/Servlet
Platform). The three previously mentioned directives are page, include
directive, and taglib directive. A directive includes <% %> brackets
and places @ in front of the directive name. For example, the
following <%@page language = “Java”%> is a page directive, with
attribute value of Java that is enclosed between the quotation marks
and with language as a directive attributes. The include directive lets
one insert a file into the servlet at the time the JSP file is translated
into a servlet and taglib directive helps one to define its own
customized tags.
Unlike directives, action elements come into play during the
special request-processing phase. Actions provide JSP running time
behavior and specify the existing components that should be used. An
example of the action element is <JSP:forward page = “URL
address”/>. Action elements prefixed with JSP are standard actions
such as forwarding request to another page as in our example.
Finally, scripting elements bring everything together in a JSP.
The scripting elements can be declarations that define variables and
methods, expressions that are used for evaluation of the request-
9
processing phase, and scriptlets that represent mini codes embedded
within JSP. Declarations have the following syntax <%! Code %>.
They do not generate any output and therefore are only used in
conjunction with expressions or scriptlets. The syntax of expression is
<% = Expression %> and is used to insert values directly into the
output. “The Java expression is evaluated, converted to a string, and
inserted in the page” (Java Server Pages (JSP) 1.0). Finally, if we want
to perform a more complex task instead of just simply inserting an
expression into a page, we can use scriptlets. They have the following
form: <% Java Code %>. Scriplets can contain expressions and
declarations of variables. Also, like expression, they are performed at
request-processing time (when the page is requested).
JSP technology is evolving everyday. There is a new JSP 2 being
developed with some features not available in the first version of JSP.
Some of the new features are simple tag extensions and the JSP
Expression Language (JSP EL), which can be used instead of scriptlet
expressions. With simple tag extensions, the amount of code needed
to write powerful web applications will be reduced.
Java Server Faces Technology
Java Server Faces technology is used to simplify the process of
building the user interface for Java Server applications. “With the well-
defined programming model that Java Server Faces provides,
developers of varying skill levels can quickly and easily build Web
10
applications by assembling reusable UI, [user interface], components
in a page, connecting these components to an application data source,
and wiring client generated events to server-side event handlers” (Java
Server Faces Technology). Java Server Faces technology is a very
powerful way to handle the complexity of user interface. This is a
programming model that can be used by any Web page developer,
including those that have no programming background, to link the
application codes without writing any scripts. Java Server Faces
technology is designed to be very flexible with no limits to a particular
mark-up language, certain protocol or special client device. “Java
Server Faces technology includes:
a set of APIs for representing UI components and managing
their state, handling events and input validation, defining
page navigation, and supporting internationalization and
accessibility, [and]
a Java Server Pages custom tag library for expressing a
Java Server Faces interface within a JSP page” (Java Server
Faces Technology).
Java Server Faces technology are a very powerful tool for handling the
user interface on the server therefore allowing the application
developers to focus only on the application code.
Java Server Pages are modeled as being composed of two
distinct conceptual elements. These two elements are the client page
11
and the server page. “A JSP is really a hybrid between a Web page for
the client side and some logic that executes on the server side”
(Ahmed & Umrysh 166). The client side and the server side have a
special relationship among themselves that is defined as a build
relationship. A “build” relationship means that the server side builds a
client page and formulates a result in HTML or XML and sends it to the
browser, which originally sent the request from the client side.
Furthermore, JSPs provide very effective yet simple vehicle for
the interaction with end users. To understand how JSPs are used in
applications, let’s start with the example of a simple, dynamic billing
form. A billing Web page is an appropriate means for presentation to
the user when the user attempts to register for certain activity or
service via the Internet and wants to make a payment by using a credit
card. We create a servlet to handle the processing of the billing form.
The following is the example of the written JSP code as well as the
result of the dynamic form once the code is executed.
Listing 1: dynamicForm.JSP (JSP: Creating Dynamic Forms)
1: <HTML><HEAD><TITLE>Dynamic Form</TITLE></HEAD> 2: <BODY> 3: <B>Form</B> 4: <FORM ACTION=dynamicForm.JSP METHOD=POST> 5: <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0> 6: <% String[] textFields = {"FirstName","LastName","Address","City","Zip"}; 7: for(int j=0; j<textFields.length; j++){ %> 8: <TR> <TD> <%=textFields[j]%>: </TD> 9: <TD> <INPUT TYPE=TEXT NAME=<%=textFields[j]%>> </TD>
12
10: </TR>11: <% } %>12: <TR> <TD> State </TD>13: <TD> <SELECT NAME=State>14: <% String[] states = {"AZ", "CA", "NM", "MA", "ME", "MD", "..."};15: for(int s=0; s<states.length; s++) { %>16: <OPTION><%=states[s]%></OPTION>17: <% } %>18: </SELECT></TD>19: </TR>20: <TR> <TD> Card Number </TD>21: <TD> <INPUT TYPE=TEXT NAME=cNumber></TD>22: </TR>23: <TR> <TD> Card Type </TD>24: <TD> <SELECT NAME=CardType>25: <% String[] cTypes = {"Amex", "Visa", "Master Card", "Discovery", "..."};26: for(int t=0; t<cTypes.length; t++) { %>27: <OPTION><%=cTypes[t]%></OPTION>28: <% } %>29: </SELECT></TD>30: </TR>31: <TR> <TD> Expiration Date (MM/DD/YYYY) </TD>32: <TD> <INPUT TYPE=TEXT NAME=cMonth SIZE=2><INPUT TYPE=TEXT NAME=cDay SIZE=2>33: <SELECT NAME=cYear>34: <% int startYear = 2000;35: int endYear = 2010;36: for(int y=startYear; y<endYear; y++) { %>37: <OPTION><%=y%></OPTION>38: <% } %>39: </SELECT></TD>40: </TR>41: </TABLE>42: <INPUT TYPE=SUBMIT VALUE=Submit>43: </FORM>44: <HR>45: <B>Form Content</B><BR>46: <TABLE>47: <% Enumeration parameters = request.getParameterNames();48: while(parameters.hasMoreElements()){49: String parameterName = (String)parameters.nextElement();
13
50: String parameterValue = request.getParameter(parameterName); %>51: <TR>52: <TD><%=parameterName%></TD>53: <TD><%=parameterValue%></TD>54: </TR>55: <% } %>56: </BODY></HTML>
The dynamic form.JSP is the entry point. It builds the login client,
which includes a dynamic form to allow the user to enter information.
14
When the form is filled in and submitted by the user, the servlet
processes it and if there is a problem it will display an error message.
JSP technology is designed to be an open, standard method
supporting numerous servers, browsers and other programming tools.
JSP speeds development of web applications by reusing tags and user
interface components, instead of relying heavily on scripting within a
page itself. Sharing characteristic of “write once, run anywhere”, JSP
is a key component in the Java 2 Platform Enterprise Edition, Sun’s
highly scalable architecture for enterprise applications (Java Server
Pages: Dynamically Generated Web Content).
ColdFusion
Another component of J2EE is ColdFusion. ColdFusion is a
commercial Web application designed for creating dynamic, interactive
Web pages. ColdFusion is very similar to Java Server Pages, as
discussed earlier in this document, although ColdFusion is primarily
used for developing database applications while JSP is primarily used
for Web applications. Organizations can implement ColdFusion or Java
Server Pages into their Web site to enhance their Web presence,
integrate logic, and build fun, functional Web pages. Which one they
choose depends on the individual need.
In the online book, The Cold Fusion Web Database Construction
Kit, the authors emphasize that users of ColdFusion are able to create
‘dynamic data-driven’ Web sites, avoiding the use of static pages or
15
fixed text images. Users are able to collect, read and write information
in other applications, and even design and create their own full-blown
applications. ColdFusion is enabled to be compatible with the Java
J2EE service platform, “add[ing] rapid server scripting capabilities to
the J2EE infrastructure, while increasing development productivity and
enjoying full access to the powerful J2EE platform” (CFMX for J2EE).
ColdFusion is built with the standard HTML, (Hypertext Markup
Language), but is able to communicate with XML, (Extensible Markup
Language), WML, (Wireless Markup Language), JavaScript, and other
Web languages as well.
Macromedia, who has recently merged with Allaire, the original
creator of ColdFusion, has created its own version of the application,
called ColdFusion MX. This product includes the Macromedia Flash
Remote component, which is used to build rich Internet applications.
In the article, A Striking Balance, Tom Yager explains the compatibility
of Macromedia’s Flash Remote components, including ColdFusion MX.
He verifies that the new Macromedia MX applications run on both
Windows and Macintosh systems and support several Internet
applications environments. Yager continues to explain that “the
ColdFusion MX scripting server runs stand-alone, linked to a J2EE
application server such as IBM, WebSphere, or paired with
Microsoft.Net.” ColdFusion MX and the original ColdFusion support the
same fundamental functions, assuming this, we will focus on the
16
purposes, the operations and how the software is implemented,
encompassing both ColdFusion and the MX version created by
Macromedia.
Macromedia describes their product as providing an additional
platform for existing ColdFusion developers to apply their skills and
establish their ColdFusion applications. “ColdFusion MX can be
configured to use your J2EE application server’s session management,
enabling the user to share any session data with other JSPs or servlets”
(JDJStore.com). In a recent article, IBM, Sun court Macromedia, Patrick
Dorsey, the Group Marketing manager for application and Web server
products states that this creation, ColdFusion MX, will combine
ColdFusion and Java together, making it easier for ColdFusion
developers to use Java.
ColdFusion software was designed to improve Web pages,
eliminating static pages with fixed text. Web pages have the ability to
become multifunctional, displaying information as well as
communicating with other databases without manual intervention. In
the online book, The Cold Fusion Web Database Construction Kit,
Crawford has supplied a list of features in which the ColdFusion
software can perform. Among the features are, “The ability to query
existing database applications for data, the ability to create dynamic
queries facilitating more flexible data retrieval,[and] the ability to
customize the display of dates, times, and currency values with
17
formatting functions.” ColdFusion also has similar attributes to Java
Server Pages, in the ability to run if/then statements as well. Further
benefits of ColdFusion are the ability to execute conditional code on-
the-fly and to customize responses for specific situations. ColdFusion
MX also possesses the capability of ‘Internationalization,’ in which the
application is able to translate and support various global languages,
“non-Latin languages, such as Chinese, Japanese, German, (etc…),
with built-in support for Unicode encoding” (CFMX for J2EE). With
many more functions for use, the logic within ColdFusion is not at all
limited. The tools and capabilities are endless.
Traditional Web pages consisted of still, ‘static’ text. Static Web
pages differ greatly from dynamic Web pages in the fact that they
contain mainly text and images. Dynamic pages only require a small
amount of actual text. ColdFusion dynamic pages are concentrated to
extract and use data from other applications, and already existing
client-server database systems in order to complete specific functions.
ColdFusion has the “ability to execute stored procedures in databases
that support them” (Crawford et al).
Static pages were manually created with traditional
programming languages. If information was to change, the Web page
had to be manually updated. This process included various steps, such
as, “first transferring the page into an editor, making the needed
adjustments, reformatting the text if needed, and then saving the file”
18
(Crawford et al.). By the time the static pages are updated, the ‘new’
information may already be ‘out of date.’ ColdFusion Web pages
remove this tedious process by eliminating the need of traditional
programming practices; “the [ColdFusion MX] pages execute on the
Java application server, taking advantage of the high performance and
reliability of the enterprise-class platforms” (CFMX for J2EE). Because
ColdFusion pages query existing database applications for data, there
is no manual updating needed, resulting in real-time information.
Consequently, time can be managed and used in an appropriate and
efficient manner when implementing the ColdFusion application.
Mohnike, of HotWired.lycos.com, explains the process of the
installation process of the ColdFusion software. The user is required to
have ODBC, (Open Database Connectivity Server), accessible
database, and driver, which is an application server that can connect
to external databases. Upon meeting the previous mentioned
requirement, the remaining process is very simple. Basically, installing
ColdFusion is considered to be comparable to installing any other
commercial based software application. The user follows the prompts
received and reboots the computer. Once installed, the user selects
the database source name, DSN, via a prompted Web page interface.
The templates used in ColdFusion, as mentioned above, are
modeled after the HTML pages, which makes the application
straightforward, effortless to learn, and easy to apply. Due to the large
19
scalability of ColdFusion, one template may be used for all of the user’s
information, instead of having to create a separate page for various
items.
ColdFusion programming language is designed to extend HTML
style tags. The language is called CFML, ColdFusion Markup Language,
and is simply modeled after Hypertext Markup Language. ColdFusion
integrates special tags that communicate to the application to perform
specific functions and operations. ColdFusion tags are easily
recognized; they all begin with the letters ‘CF,’ for example, <cfmail>
and <cfoutput>. When programming ColdFusion, the user does
apply standard SQL and HTML programming languages, CFML helps to
distinguish between the parameters of these languages.
The templates of ColdFusion all use the file extension of .cfm.
“Essentially, a template is a standard HTML page with some extra
coding inserted before the <HEAD> tag. This code tells ColdFusion
which data source the user wants to access, and sets up variables that
will be used further down the page in the actual HTML code.” In
addition, the ColdFusion variables are always surrounded by pound
signs (Crawford et al.). The information requested between the pound
(#) signs is the information that is being extracted, in essence, what is
being obtained. The user has the advantage to customize these tags
in accordance to their needs. All that is needed is the <cfoutput> tag
and the name of the defined query and the user is able to retrieve any
20
information he or she requests. From there, within the database, the
user may choose to enable or disable the options within the fields
given in each Attributes table.
The following three examples are courtesy of Charles Mohnike,
from the ColdFusion Tutorial. This first example shows the query name
as, “pocket,” from the data source of “contents of my pocket.” The
name of the template must match the name in the <cfoutput> tag.
“Contents of my pocket,” is the primary information requested.
“Select” in the example is standard SQL programming language,
indicating that the information requested is retrieved from all of the
fields within “contents.”
<CFQUERY NAME= "pocket" DATASOURCE= "contents_of_my_pocket">SELECT * FROM contents</CFQUERY>
If the user were to access the information above, he or she may
possibly retrieve the following data:
A Bus Transfer
14 December 1998
One Plastic Baggie, Empty
12 December 1998
A Ticket for Having an Unleashed Dog in the Park
21
12 December 1998
The next template example tells ColdFusion to select all the
records from a specified date. ColdFusion is requesting the
information from the table ‘Contents,’ where the field acquired exactly
matches the text, “12 December 1998.”
<CFQUERY NAME= "pocket" DATASOURCE= "contents_of_my_pocket">SELECT * FROM contents WHERE acquired IS "12 December 1998"</CFQUERY>
The feedback resulting from this query would be:
One Plastic Baggie, Empty
12 December 1998
A Ticket for Having an Unleashed Dog in the Park
12 December 1998
To show how functional and specific the user may be, the
following is yet another example of the versatility of ColdFusion. In
this example, the user is requesting to select “contents of my pocket”
that only begin with the letter “b.”
<CFQUERY NAME= "pocket" DATASOURCE= "contents_of_my_pocket">
22
SELECT * FROM contents WHERE item LIKE "%b%"</CFQUERY>
ColdFusion can also be programmed to reply to a user by
sending an e-mail message based on a specific query or enabled
attribute field. The following example is from the online book, The
Cold Fusion Web Database Construction Kit. The authors show that
with the <cfmail> tag attributes enabled, ColdFusion is able to send or
reply automatically to anyone who accesses their Website. The
example shows that the responding letter sent from the Website to the
frequent user can be personalized to present added comfort to the
user as well.
<CFMAIL QUERY="MailingList“FROM="[email protected]" TO="#EMailAddress#" SUBJECT="Monthly Online Newsletter“>Dear #FirstName#,This e-mail message is to remind you that our new monthly
onlinenewsletter is now on our web site.You can access it at http://www.a2zbooks.com/newsletterThanks for you continued interest in our product line. A2Z Books Sales</CFMAIL>
In the world today, security is a major factor. There are many
companies that are actively involved with e-commerce. There are also
many consumers who use the Internet for various practices, such as
purchasing and selling items, and do online banking. Both consumers
23
as well as companies doing business trust that the information being
passed through the World Wide Web is kept personal, and used
specifically for the purposes requested. Security is an unprecedented
requirement today.
Originally, ColdFusion was based on a script within a CGI
(Common Gateway Interface) program. Security was a large threat,
hackers were able to manipulate and sabotage the CGI programs.
“Hackers have discovered that they can attack these programs and
scripts in a variety of ways by inputting invalid data, ultimately,
disrupting the program within the Unix Web server to list the contents
of password files and retrieve sensitive information” (Turban et al.
559). Improvements were implemented within the ColdFusion
application, as a result, security can be managed, and additional
controls may be set. The applications within the Java server are
controlled by J2EE security settings. Macromedia has created “Server
Sandbox Security… secure shared hosting environments with
directory-based access control for tags, functions, data sources, and IP
addresses” (macromedia.com). ColdFusion also has the advantage of
configuring custom ‘probes’ to monitor server activity and react with
automatic alerts.
ColdFusion is very user-friendly, easy and quick to learn. The
complication of creating a web page with ColdFusion is decreased
dramatically. When using ColdFusion to create a web page, the user
24
no longer needs to have the pre-required knowledge of UNIX and
traditional scripting languages. As mentioned above, ColdFusion also
integrates with various Web languages such as XML, WML and
JavaScript. The software “contains all the processing and formatting
functions needed, provides all the tools needed to troubleshoot and
debug applications, and can link to almost any database application”
(Crawford et al). There are also telephone and online sources that may
be contacted for further troubleshooting.
Although there are great benefits and competitive advantages
among the users of ColdFusion, there may be obstacles as well. For
example, the barrier of high cost of the application. According to
Macromedia JDJStore.com, pricing for ColdFusion MX can range from
$550.00 to more than $7000.00. For large corporations, this
investment will be easily recovered within a short time period. For the
smaller companies, with the advantages and options the application
offers, making the purchase may be a risk worth taking in order to
expand and create a genuine Web presence. The opportunity cost
involved may or may not outweigh the cost depending on the results
obtained from the user.
A multitude of companies, such as AFLAC, Bank of America,
Pepsi, Macy’s, and the FDA, along with many others, have
implemented the advantages of ColdFusion. ColdFusion can be used
to improve all types of Websites for all types of companies, from
25
advertising products to promoting services. Ben Forta of Forta.com
states that, “ColdFusion is used by over ½ million developers on over
60,000 servers, making it the most popular commercial cross-platform
application server on the market.” In addition, there are many Web
providers that offer the ColdFusion services, (Mohnike).
Within an organization, ColdFusion could be installed to perform
“Manipulation Functions, such as text parsing, comparison and
conversion functions, Mathematical Functions, and various other
System Functions” (Macromedia CFMX). Organizations are not limited
in their use of ColdFusion with the Internet alone. ColdFusion can also
be implemented within an Intranet as well. This is yet another
advantageous tool, of which, can be used within the LAN firewalls of an
organization to bridge communication, or convey information.
The technology operation and consistency of ColdFusion is
seemingly boundless. ColdFusion MX pages “ensure high performance
and reliability by leveraging the full power of the Java Technology
platform, saving the expense of the time and money it would cost to
implement a ‘pure Java’ solution- and they can deploy it to their J2EE
standard” (Macromedia CFMX). The innovative application allows the
user to easily build ‘data-driven’ applications delivered into the
browser. ColdFusion MX is capable of “deliver[ing] a more compelling
user experience while providing a robust architecture and rich set of
26
built-in capabilities to deliver high performance and scalability” (CFMX
for J2EE).
The numerous functions presented are extremely useful, and
produce undeniable advantages to the many organizations that have
recognized and implemented ColdFusion. We have all heard the
phrase, ‘time is money,’ and with the use of this exceptionally valuable
application, organizations are able to use their time more efficiently
within their environments, working to improve profits, rather than
updating web pages.
JAMBA
To reiterate what was mentioned earlier in the paper, Java is a
powerful object-oriented computer programming language that is often
used by experienced programmers to build substantial information
systems. The key word here is experienced. Unfortunately, for those of
us with little background in Java, it might seem impossible to handle a
grasp on it. The compiling of codes and programs might seem
extremely overwhelming; this is probably because Java is very difficult
material to pick up on.
Let’s say that an average Joe wanted to use Java to enhance his
small company’s WebPages, however, he lacked any real expertise in
that specific programming language. What could he do? Firstly, Joe
could attend several Programming (specifically Java) courses and gain
expertise on the subject for himself. This would cost a lot of money,
27
time and effort. Secondly, Joe could forget about attending classes and
hire a full time computer programmer (Java developer) to do the job for
him. However, it would be difficult for a small company to maintain a
full time computer programmer on its payroll. Thirdly, Joe could get his
hands on the Java authoring tool, JAMBA. Java development using
JAMBA would be the perfect way to go!
According to Interleaf, Inc., “JAMBA is an award-winning Java
authoring tool that lets create Java applets and applications in a visual
drag-and-drop environment, without programming, scripting or plug-
ins.” An applet is a small program that normally is stored on a remote
computer that users connect to via a World Wide Web browser. Applets
are loaded from a remote computer into the browser, executed in the
browser and discarded when execution is completed (Deitel, 2002).
Java applets are often time-consuming to configure and run. However,
with the assistance of JAMBA, applet forming has been made simpler.
Interleaf, Inc. is a company that offers enterprise-wide software
solutions for substance management and complex publishing. These
solutions enable customers to set up document-based applications that
progress their operating efficiency and customer satisfaction, and
support revenue and profitability (Business Wire, 1998). Among these
solutions is JAMBA. The company has received many awards for this
prize development such as PC Magazine Editor’s Choice Award for
multimedia design ability in a Java Applet Tool.
28
JAMBA is designed for Web content creators who would like to
gain from Java’s ability to add functionality and interactivity to
stagnant HTML (Hypertext Markup Language) pages. JAMBA offers a
non-programming environment using a point and click interface that
allows for feature-rich Java applets that run across all major Web
browsers. Unlike others that use a plug-in approach, JAMBA applets do
not call for the browser to first download and install plug-ins before the
applet can be viewed (Business Wire, 1998).
JAMBA is a successful animation tool that enables Web Page
designers to easily integrate sounds, graphics, text and special effects
to make their pages come alive with movement and sound activated
by the user. Not only is JAMBA’s ability to play music files impressive, it
is also notable how Web users are able to experience extensive
interaction with the HTML (Hypertext Markup Language) pages
(Business Wire, 1998). Some examples of JAMBA’s exquisite
capabilities include creating guest books, ticker tape, push buttons,
image strips etc.
JAMBA is great for adding multimedia, such as graphics that pop
up at the wave of a mouse, page events that are controlled by timers,
interactive elements (list boxes etc.), or a mouseover graphic that
sends the user to another site when clicked on. JAMBA can also be
used to collect information from people on the Internet, and then
29
circulate that information to a data file on a server (Developing
Distributed Application, 1998).
Contained in the JAMBA development environment are Visual
RAD, Wizards and, of course, Drag-Drop. Once you have installed
JAMBA, you are ready to create your own applets quickly and easily.
JAMBA has been commended on its easy to use, fairly self-explanatory,
and uncluttered interface. According to Vicky Dawson’s “JAMBA 2.0”
article, a clear workspace is provided (where applet creation takes
place) along with a JAMBAPlayer (used to run projects as you are
working on them to ensure they’re running correctly), a screenshot (to
keep track of your project), and a toolbar (that includes all the tools
needed to complete the project).
Since you don’t need to know how to program to create applets,
you can drag and drop whatever operation is needed throughout the
whole project. Wizards are excellent for helping create small applets,
such as rollover buttons, animations, and ticker tapes. When
everything is complete, your work can be instantaneously published to
your web server or local drive (all files necessary to run the project are
stored here together.) All that is needed to get the application to work
is to cut and paste code into the .html file you want the applet to run
from (Dawson, 1999). Since there isn’t any plug-ins to run the applets,
Web users don’t have to download anything to view your page
(Dawson, 1999).
30
JAMBA is a product that is very simplistic, prevailing, widespread,
portable, and considered the easiest way to create Java applets. We
also know that JAMBA is being used for the purpose of enhanced
efficiency and livelihood of HTML (Hypertext Markup Language) pages.
However, where does one go about actually creating a JAMBA applet or
application?
Steps to Using JAMBA
It all starts with the JAMBA interface, which is considered JAMBA’s
main selling point because it is so simple to follow. Below is a screen
shot of the interface that includes the JAMBA Project Window (far left),
the Page Layout Editor (middle bottom), the Object palette (far right),
the Properties and the To Do List (middle top). All of these will be
explained in the following pages.
31
Starting a New Project (Lesson: JAMBA Quick Start):
Choose “New” from the file menu or click on the “New” button
to start a new application project. The “New Project” dialog box
will appear, as shown below. This is where you name your application,
decide which directory you want the application to reside in, and set up
the size of the window the application will run in. If you name a
directory that doesn’t exist, JAMBA will create it for you.
The JAMBA Project Window (Lesson: JAMBA Quick Start):
After you have started a new project, the first window that
comes up is called the JAMBA Project Window. This is where you view
thumbnail sketches (small representations) of the pages that structure
your application. The first page is always called the “start page”. As
you create more pages, more thumbnail sketches will appear in the
Project Window. Most applets/applications created for use on the
Internet only need one page to construct.
32
The JAMBA Project Window & Start Page
The Page Layout Editor (Lesson: JAMBA Quick Start):
To open up the Page Layout Editor, double click on the Start
Page in the Project Window. The Page Layout Editor (displayed below)
is the area where you draw objects on a page and arrange the objects
to perform as needed to at runtime. The Page Layout Editor consists of
two parts: the Object List and the Layout Area. The Object List is the
area to the left that lists the names of the objects used on each page.
The Layout Area is the area to the right that serves as a canvas to
draw objects on.
33
Setting the Window Size (Lesson: JAMBA Quick Start):
This is where you set the window size or adjust the window size
to accommodate your application/applet. This can be done by choosing
“Settings” from the Project menu and clicking on the “Page” tab.
Drawing Objects (Lesson: JAMBA Quick Start):
34
To draw an object you must use the Object Palette (displayed
below on the left), this is a tool bar that presents particular objects that
can be used to create an applet/application. Objects are the building
blocks that make up an applet/application.
Some examples of objects are:
Push Buttons- creates a variety of buttons like “OK” or
“Next”.
Graphics- creates graphic files that you can incorporate
into an application.
Audio- creates audio files to play within your application.
List Boxes- creates a list of items you can scroll down and
choose from.
Text Fields- creates the display of editable text within your
application.
Setting Object Properties (Lesson: JAMBA Quick Start):
After using the Object Palette to draw objects, you must set
properties to these objects. This is done because each object and page
has certain properties (characteristics) that must be set in order to
control their appearance. For example, with a push button object you
must set its’ label property to “OK” or “Next”. To bring up properties
(as shown below), you must right click on the object you are setting
properties for, choose “properties” from a pop up menu, and then click
35
on the “properties” tab. From there you can adjust the properties to
best suit a specific object.
The To Do List (Lesson: JAMBA Quick Start):
The To Do List is JAMBA’s most powerful feature. It tells objects
what they should do when a particular event occurs. For example, if
you click on a button labeled “play”, an audio file will play. To
manipulate the To Do List (as displayed below), right click on the
object you are working on, click on “properties” from the pop up menu,
and click on the “To Do List” tab.
The drop down box lists events that will cause particular actions
to occur. In the image above, the event is a click on a push button. The
36
empty space below is where these To Do Items, particular actions that
occur from a click of the button, will be listed. To administer the blank
area to fill in the To Do Items, just click on the “New To Do Item”
button (as shown directly below).
Once you have clicked on the “New To Do Item” button, you can
fill in the “Object”, “What to do” and “Value” portions of the To Do List
(as displayed below). A drop down box of all objects you have created
will appear. In this example, an audio object has been chosen. In the
“What to do” section, another drop down box will appear that lists
certain actions that can occur. In this example, an audio file was
chosen to play when the button is clicked on.
Completion of Application/Applet (Lesson: JAMBA Quick Start):
37
After all objects have been assigned valuable properties and To
Do Items, test the application. If everything works properly, you can
distribute the application/applet to your end-users or you can
incorporate the functionality into your own web page.
Jini Technology
You have just learned about JAMBA, one of the attributes offered
through the Java J2EE platform. Another offering of Java J2EE is Jini,
which is one of the underlining technologies of JAMBA.
Jini is not an acronym for anything; it was formed from the work
of Java, making connectivity and distribution easier. It was
implemented to make network devices and network computing into
standard components for the end-user computing environment. Jini is
a way to build embedded systems and provide an easy and flexible
way to distribute these systems. To explain this, an embedded system
or client is a car or a washing machine with an embedded microchip.
In many cases, an expert system is embedded with rules that make
the client smarter or more responsive to changes in the environment.
For example, if you were to buy some new office equipment such as a
desk lamp, or a alarm clock, Jini will not only carry out its traditional
function but will join into a network of other computer devices and
services. The desk lamp will shut off by itself when you get up from
you desk, informed by sensors in you chair; the alarm clock will tell you
coffee maker to turn on a couple of minutes before it wakes you up
38
(Venners,1999). Another example given by Venners of how Jini can be
useful is: it can allow a digital camera the ability to connect to a
network; when an interface appears, it is able to show the picture and
can detect your printer to print the picture. These are some of the
services that Jini provides from its new technology. “Others are:
A configuration file that is copied and modified on
individual machines can be made into a network service
from a single machine, reducing maintenance costs for a
company.
New capabilities extending existing ones can be added to a
running system without disrupting existing services, or
without any need to reconfigure clients.
Services can announce changes of state, such as when a
printer runs out of paper. Listeners, … , can watch for
these changes and flag them for attention” (Overview of
Jini, 2000).
Some of the reasons why Jini technology is becoming more of a
demand are because the people are not using their PCs for word
processing as much any more. They are using network to gain more
services and more resources and to interconnect with one another.
In recent years there has been a lot of new technology popping
up for the end users to enjoy. Some of these technologies are called
wireless devices that don’t have to be plugged in to an outlet or don’t
39
have power cords. “These wireless devices have small embedded
devices (anything with a microprocessor embedded in it that has a
relatively focused functionality). An example of these embedded
devices are cell phones, microwave ovens, VCRs, pagers, clocks, and
printers” (Perrone, 1999). As you might have noticed, computers are
not on the list. Why? The answer is, computers don’t have a focused
functionality. So, what is meant by a focused functionality? Consider
the following example: a microprocessor-enhanced typewriter is an
embedded device, focused on the job of typing. A computer running a
word processor can serve the same purpose as the typewriter, but the
computer can also be used to run a spreadsheet, surf the Web, or do
many other activities. The computer also has a disk that is used to
store information on it and enable it to run the computer. The
functionality of the computer is so spread out, and its operating system
is so large, because it has to know about everything that the computer
is capable of doing. With these new embedded devices other systems
are diskless since they have a certain functionality that they will be
performing. As Jim Waldo, Sun’s chief Jini architect puts it, “Given the
rising importance of diskless, network-connected embedded devices,
however, this disk-centric model for computing doesn’t fit anymore.”
Waldo also explains, “Jini attempts to provide an architecture for the
emerging network-centric hardware environment, an architecture
based on the idea of a federation rather than central control, new
40
technology for a networked world” (Venners, 2002). Jini is
implemented to define a set of rules for the federation that will in
return enable clients and services to interact.
Several technologic development efforts are underway to answer
the problem of being more interconnected and an easier way to build,
manage, and use the services of a digital network. This is where Jini
comes into play. The Jini technology makes a network more dynamic
by allowing the ‘plug-and –play’ of devices. It gives devices the ability
to attach and detach from networks without configuring each device
each time. You might think that Jini is an operating system, but it isn’t,
it just defines a set of rules that enable clients and services to interact
with one another. Because Jini systems don’t have a central point of
controlling authority, if something goes wrong it won’t bring the whole
system to a halt.
So, how does Jini work? Before further discussion of that, here is
a quick overview of how it works. Once the overview is established,
then the components will be explained. When a computer starts up, it
looks for a disk. If it doesn’t locate a disk, it can’t function. These
implementations of networks are what Jini is all about. When you use
an interaction device that is a part of a system that is implementing
Jini technology, the services are there to use as though you were on
your own computer. These services also include software as well as
hardware. This is a trend in the hardware environment, from disk to
41
‘network-centric’. These embedded devices have a processor, some
memory, and a network connection and are what Jini is going to
implement.
Jini is going to become the ‘thinker’ that reconsiders how this
computer architecture is going to be constructed. What does
architecture of a computer refer to? “The term architecture is used
because it is describing the design of Java to allow for future expansion
of server and reference types so that RMI can add features in a
coherent way” (Javaworld, 1999). From here Jini is developed and built
on top of the Java 2 platform, object serialization and RMI (Java Remote
Method Invocation). Before proceeding further, let’s explain what
exactly is meant by the terms RMI and Java 2 platform. Java Remote
Method Invocation allows a user to write distributed objects using Java.
“RMI provides a simple and direct model for distributed computation
with Java objects. These objects can be new Java objects, or can be
simple Java wrappers around an existing API. Java embraces the write
once, run anywhere model. RMI extends the Java model to be run
everywhere” (Javaworld, 1999). RMI can connect to an existing legacy
system using the standard Java native method interface JNI. A user
can use RMI to connect between a new Java application and existing
servers. “RMI allows the parts of your system written in Java to flow
from the existing Java components into the new Java code”(Javaworld,
1999). For example, “Using RMI means that you can get Java benefits
42
throughout your system by using RMI as the transport between client
and sever, even if the server remained in non-Java code for some time”
(Venners, 2002). RMI is explained even further later on in this paper.
What is the Java 2 platform? It is made up of RMI, security,
networking, and serialization. The Java 2 platform offers new security
and distributed communication mechanisms on which Jini relies. RMI
objects can move around networks from ‘virtual machine to virtual
machine’. Because Jini is being the thinker, device vendors don’t have
to agree upon network protocols to which their devices can
communicate, rather Jini does all the work by enabling the devices to
communicate with one another through interfaces to objects
(Hashman, 2001).
What is a Java Virtual Machine? Java Virtual Machine is known as
the ‘cornerstone’ of Sun’s Java programming language. “It is the
component of the Java technology responsible for Java’s cross-platform
delivery, the small size of its compiled code, and Java’s ability to
protect users from malicious programs” (Hashman, 2001).
Jini, or called federation, is the gathering of services and clients
that interact by using Jini protocols. “The federation part of Jini is the
gathering of networks of devices, software services that are assembled
together to from workgroups known as federations of clients and
services, without the need for intervention by system administrators”
(Venners, 1998). The protocols and applications are written in Java,
43
and talk to one another using RMI. Jini supports a ‘middleware’ layer
that enables services and clients to communicate. Jini is made up of
APIs (Application Programmer’s Interface) and network protocols so
that the user can write services and components that use this
middleware, organized as federations of services. “A federation of
services is a set of services, currently available on the network, that a
client (meaning a program, service, or user) can bring together to help
it accomplish some goal” (Perrone, 1999). Because there is no one
service in charge, the word federation is used to describe the basis of
Jini’s view of the network. These services form groups that are
composed of ‘equal peers’, which allow clients and services to find
each other (a look-up service, which stores a directory of currently
available services).
Jini has a runtime infrastructure, which allows you to add,
remove, locate and access services. Services use a runtime
infrastructure to make themselves known when they join the network.
A client uses the runtime infrastructure to locate and contact desired
services that the end user will be implementing to accomplish a task.
According to B. Day of Java World, the desired service could be hooking
up a printer, and while Jini is configuring it, the protectors perform
look-up, discovery, and join to allow you to receive a service, which in
this case would be printing.
44
From this, runtime infrastructure introduces three main players:
a service, such as a printer; a client, which would make use of the
service; and there is a look-up service that acts like a ‘broker’ between
services and clients (Jini technology). When a new service become
available within the network, it registers itself with the look-up service.
The client then uses the look-up service to locate services to assist
with a given task. The last component that intertwines the first three
is the network, which is generally running TCP/IP (Transmission Control
Protocol/ Internet Protocol).
The runtime infrastructure of Jini also consists of a network
protocol, called discovery and two object-level protocols, which are
called join and look-up. In the diagram below it shows where these 3
protocols are located. The process of discovery, join and look-up are
the last steps before these transactions turn into Jini services. These
services could be printing, paging or telephony.
45
First I will describe the discovery process. “Discovery is the
process by which a Jini technology-enabled device locates look-up
services on the network and obtains reference to them”(Venners,
1999). For example, as soon as you connect the drive to the network,
it announces itself by dropping a multicast packet onto a well-known
port. Embedded in the presence announcement are two important
pieces of information: the IP address and port number where the disk
drive can be contacted by a look-up service, and a list of names of
groups the device is interested in joining.
Next comes the joining process. When a device is discovered by
a look-up service, it then can register its services on that look-up
service. This is called the join process. From here, the join process
starts off when a service attaches itself to a look-up service and the
object it established from that look-up service during the discovery
process. The look-up service then stores the information downloaded
from the service and links that service with the requested group. At
this point, the service has joined the group on that look-up service.
The look-up process works like this. Once a service has joined up
with at least one group within a certain look-up service, that service is
accessible for the use by other clients who want that particular look-up
service. “To build a federation of services that will work together to
perform some task, a client must locate and enlist the help of the
46
individual services. To find a service, clients interact with look-up
servers. These processes are what make up the look-up services”
(Venners, 1998). To better describe this process consider the following
example: A client program may look up a printer service in a look-up
service. This program starts the look-up process by calling upon a
method in the object received from look-up service during the
discovery process. The client identifies the type of interface that will
be implemented by the printer service. The look-up server finds a
printer service that matches the request. It then sends the object that
matches this printer service back to the client. Not only does the client
have the object that is requested, but also is able to implement the
service by the Java based interface. This is an object that acts as a
representative of the printer service. With this object, the printer now
can produce the service of printing to the end user.
The other part of Jini is the programming model that consists of
leasing, transactions and distributed events. These models are
described in the following paragraphs, as well as what each of the
three parts do. The programming model is shown in the diagram
above, located under the infrastructure of discovery, look-up and join.
In most distributed system, the user may encounter server crashes,
traffic jams and wires can be cut. “The programming model offers a
small set of APIs that can help the end user to create reliability in your
distribution system. The programming model helps clients and
47
services to do the work for which the federation was assembled in the
first place” (Venners, 1998).
To explain the three parts of the programming model, we will
first start with leasing. Leasing offers a way to run the ‘lifetimes’ of
distributed objects that can’t be managed by the standard rules of the
federation. Leasing is the amount of time that an object has to carry
out its function. For example, if you were performing a service of
printing, this printing service would get to decide the amount of time of
the lease, most likely taking the demanded time period into account,
and corresponding that time period back to the client. But, if the client
does not make use of this lease before the time period is up, the
printer can assume the object is no longer needed by the client and
can get rid of the object. As long as the client keeps renewing the
lease before the time period is up, the printing service will not be
discarded and the service remains available to the client.
Transactions are the second part of the programming model that
help the end user to create a reliable distributed system. “It refers to
the mechanism used to ensure that service operations are consistent
and complete within the federation” (Venners,1998). A transaction can
allow a set of operations to be clustered in such a way that they will
either all work or will all fail. Within the federation, it allows a pair of
operations in the set to appear or occur, at the same time. By
implementing transactions, consistency can be enforced over a set of
48
operations on one or more activities. “If all the participants or services
are members of a transaction, one response to a remote failure is to
stop the transaction, thereby ensuring that no partial results are
written” (Venners, 1998). So overall, the transaction creates a more
reliable distribution system.
The distributed events model is the third part of the distributed
system model. “In this model, objects on a device can register their
interest in an event occurring in another object residing on a different
device in the federation and receive notification when the event
occurs” (Hashman, 2001). In other words, “events provide a
mechanism for maintaining consistency of the same state of
information in the federation of services and clients working together.
Using the Jini event model, an object can register itself as a listener
interested in events generated by a remote source” (Venners, 1998).
When the remote source fires an event, the event will travel across the
network to the registered listeners. Here is where Jini’s discovery,
look-up and join processes come into play. As explained earlier, when
these devices form federations, or network communities, through the
discovery and join protocols, a device uses discovery and attaches to
one or more other devices to form a network. The device then polls
that network for the implementation of a Jini look-up service. After the
service is looked up, the device then can registers itself with the look-
up service. But the device may already host a look-up service, which
49
will then become available to be discovered by other devices within
the network. Devices within the network can call on the look-up
services they have discovered and determine whether or not there are
desired services available. From this, desired services can be
downloaded or ignored by the device. “Because this process is
automatic, devices or users don’t have to do complicated installations
to couple Jini-enabled devices to the network and enable the devices to
function easily with other devices on networks” (Venners, 2002).
LUTRIS & RMI
Another important piece of the Java 2 Enterprise Edition Platform is RMI
technology. One of the forerunners of the development and use of this
technology was Lutris Technologies, Incorporated. Lutris Technologies
is the development company of Enhydra and this is the only RMI
application that was found throughout the research of this subject.
The Enhydra program was originally developed for cross platform
applications. This was an Instant DB (Database) program that was
considered to be more successful than Oracle, because of this cross
platform application. This was known to be a significant improvement
as this program was develope once, use anywhere. It was developed
for use on UNIX, Linux, MAC or Windows based operating systems
(Businesswire).
50
By now you may be asking, so what? So was Java! What makes
this program so special? Primarily, the reason this is envisioned as a
new and innovative product, is because Java was developed for web-
based applications while still using VisualBasic programming, while
Enhydra was designed to support wireless application protocols (WAP)
and to deliver applications to the broadest range of wireless and wired
devices using the Java Language, according to the
Business/Technology Editors of Businesswire.com.
Lutris was originally touted as the greatest thing to hit
computers since the advent of the World Wide Web. As things so often
do in this time of rapidly changing technology, they were ahead of
their time and are now out of the race. Enhydra was a unique
technology using XMLC (Extended Mark-up Language Compiler), to
guarantee that developers were not required to write separate code
bases for each targeted device. Enhydra XMLC separates business
logic from presentation design, enabling a one-to-many approach that
improves application manageability (XMLC).
In 2000, Lutris Technologies was a leading Open Source
enterprise software and services company. Their clients ranged from
entrepreneurs and companies launching new Web ventures to Fortune
500 IT companies that were growing their business with an online
presence. However, development didn’t stop there. In March 2002,
Lutris announced the availability of a program designed for the MAC
51
OS X operating system. This was a Java Application Server that
featured Java Services Architecture, Web Service capabilities,
clustering functionality, and wireless and voice presentation
capabilities. This was an upgrade to the 3.5 server that was based on
an IBM compatible operating system. Now, Macintosh users could
derive some of the same benefits (MacCentral).
In the late spring of 2002, Lutris was condemned for betraying
the open source community. Up to this point, Enhydra had existed as
a commercial product as well as being an open source version.
According to instantdb.com, the company suddenly announced that
from this point forward, the Enhydra Enterprise was going to be closed
source. Arguments from the Lutris’s management that this decision
was based on SUN’s licensing conditions were strongly argued
against by other sources as being based upon the business’s bottom-
line. Why should they give their code away for free like everyone else
when they had already shown that they could convince a great number
of people to pay them for the privilege of using their code? According
to Itworld.com, in May 2002, Lutris stopped offering EAS and Enhydra
to end-users. In addition, the company ceased management of the
open source community that developed products based on Enhydra.
Enhydra is still available, but only because so many companies based
their products on this application and so far, there isn’t a bridge
between this product and any others currently on the market.
52
Lutris’ Enhydra system relied heavily on RMI (Remote Method
Invocation) for its processes, and although Lutris is no longer available,
RMI is still a very viable product. SUN has taken over this loss with
their Java Remote Method Invocation technology run over Internet
Inter-Orb Protocol. This delivers CORBA (Common Object Request
Broker Architecture) distributed computing capabilities to the Java 2
platforms. Java RMI over IIOP (Remote Method Invocation over Internet
Inter-Orb Protocol) combines the best of RMI and CORBA. It allows
developers to work completely in the Java programming language
rather than jumping from Java to C++ to VisualBasic to whatever other
programming language one might wish to implement. Clients can be
written in other languages and can still be integrated into a system
that is Java based without causing runtime errors, using switches or
writing bridges of code (Java.sun).
As shown earlier, using Java Server Pages can shorten the work
of programming, but with the XMLC portion of RMI, the designer has
greater dynamic control. XMLC features a compiler and a runtime
environment for standard Web application presentation deployment.
The compilation phase translates a targeted markup page into class.
Before compilation, the designer and developer identify areas of
dynamic code embedded with id attributes or Taglib. The designer
then uses the XMLC to generate a Java class. From there, they would
use the code and import it to a template. Each step is labeled with
53
XMLC to indicate that the job is done. This method uses only HTML
tags; there are no structural files required and no Java code has to be
written or implemented, mock data can be used and there is direct
access so the designer can make any changes he/she wishes without
developer assistance. According to David Young writing for
theserverside.com, a lot can go wrong with using JSP for more dynamic
HTML pages. If a designer were to use XMLC instead, the greatest
thing that would have to be remembered is “Don’t change the ID
attribute name”. Inexperienced programmers using JSP can break
their code very easily with a misspelled word or by using an uppercase
letter where a lower-case letter is needed. With XMLC, it won’t
necessarily look very pretty when you make the mistake, but the code
won’t break and the page will still load. JSP taglibs were developed to
fix this, but all they are is a bandage on the problem, not a cure.
XMLC provides an object-oriented method of creating dynamic
content from static HTML and XML documents. Much like JSP and
CFML, it can be used to convert HTML or XML documents into Java
classes or to mimic any Java class so that it can be used within a Java
program. In this way, the developer or designer can create dynamic
HTML for their web site applications. According to webreference.com
XMCL provides five (5) predominant advantages when used for content
development.
54
1. The development of HTML and XML documents stays separate
from their programming logic. The content can be developed
using standard HTML/XML design tools.
2. Sample data doesn’t have to be converted into another form,
it can be left in it’s original tables and still appear in a
readable form. This gives the designers the ability to work in
conjunction with the programmers; one developing the code
while the other develops the layout and design.
3. The contents of pages are easier to manipulate because of
the access methods that are generated. If the tag isn’t
removed from a page even though the code has been
deleted, the user won’t get error messages pointing out that
someone missed a step.
4. Significant performance benefits can be obtained when
parsing of an HTML/XML document is done at compilation
rather than at run time.
5. Code flow control remains separate from the page. Content
and data are not mixed in a single file that can result in the
code being difficult to understand and that would prevent the
ability to take full advantage of the object oriented
programming paradigm.
55
Enhydra XMLC works on this premise, but fortunately for current
programmers, they aren’t patented in to the use of XMLC. Even
though Enhydra was developed to use and enhance XMLC, they didn’t
get the full inalienable rights of ownership (Enhydra.org).
RMI (Remote Method Invocation) allows applications to call
object methods located remotely. They share resources and
processing loads across systems. This provides the developers with
greater access so that they don’t have to overload their servers. With
the cost of server space, this is a very lucrative feature. Unlike other
systems for remote execution, which require that only simple data
types or defined structures be passed to and from methods, RMI allows
any Java object type to be used. It facilitates object function calls
between Java Virtual Machines and it can dynamically load new classes
so the RMI will automatically update Java programs (Reilly).
Java RMI relies on Java, so it can be used in cross platform
applications. But, since RMI relies on Java, the machines that are using
it have to have a Java Virtual Machine implementation on that
platform. Each Server object defines an interface, which can be used
to access the server object outside of the Virtual Machine and on
another computer’s Java Virtual Machine. The interface shows what
set of methods indicated are to be offered by the server object. For a
client to locate a server object for the very first time, RMI requires an
RMIRegistry that runs on the server machine.
56
The following diagram shows the architecture of RMI and gives
the reader an insight to the lines and blocks of code below (jGuru).
Java RMI is a very useful mechanism for invoking methods of
remote objects. If you have ever written any Java programs, you know
that you have to call the methods that you wish to use. However, if
you write or implement a Java RMI, you can have the program perform
the call all by itself. Writing an RMI is not very easy at first, but it does
become more automatic once you’ve gotten used to it. In order to
begin, you have to first decide upon an interface. What methods do
you want remote clients to be able to invoke? To write a simple
interface, you can use the following code:
57
import Java.math.BigInteger;import Java.rmi.*;//PowerService Interface//Interface for a RMI service that calculates powerspublic interface PowerService extends Java.rmi.Remote{
//Calculate the square of a number public BigInteger square( int number ) throws RemoteException; //Calculate the power of a number public BigInteger power( int num1, int num2) throws RemoteException;}public PowerServiceServer() throws RemoteException{ super();}public static void main( String args[]) throws Exception{//Assign a security manager, in the event that dynamic classes are loaded. if (System.getSecurityManager()==null) System.getSecurityManager(new RMISecurityManager()); //Create an instance of our power service server.. PowerServiceServersvr =new PowerServiceServer(); //...and bind it with the RMI Registry Naming.bind("PowerService",svr); System.out.println("Service bound....");(Reilly, 2)
Once that is written, you have to write or implement a program that
will implement the interface. This is another simple program, but the
programs can be as simple or as complex as the programmer wishes
them to be. The following code is an example of the server:
import Java.math.bi.*;import Java.rmi.*;import Java.rmi.server.*; public class PowerServiceServer extends UnicastRemoteObject
58
implements PowerService{ /** Creates a new instance of PowerServiceServer */ public PowerServiceServer()throws RemoteException { super(); } //Calculate the square of a number public BigInteger square ( int number ) throws RemoteException { String numrep = String.valueOf(number); BigInteger bi = new BigInteger (numrep); //Square the number bi.multiply(bi); return (bi); } //Calculate the power of a number public BigInteger power( int num1, int num2) throws RemoteException {
String numrep = String.valueOf (num1); BigInteger bi= new BigInteger (numrep); bi=bi.pow(num2); return bi; }public static void main (String args[] ) throws Exception { //Assign a Security manager, in the event that dynamic classes are loaded if (System.getSecurityManager() == null) System.getSecurityManager ( new RMISecurityManager() ); //Create an instance of our power service server... PowerServiceServer svr= new PowerServiceServer(); //...and bind it with the RMI Registry Naming.bind ("PowerService",svr); System.out.println ("Service bound....");(Reilly, 4)
When that is completed, you must write a client that will use the
program. All this has to do is call the registry to obtain a reference to
59
a remote object, and call its methods. For this example, consider the
following code:
import Java.rmi.*;import Java.rmi.Naming;import Java.io.*; public class PowerServiceClient
{
public static void main( String args[] ) throws Exception { //Check for hostname argument if (args.length !=1) { System.out.println ("Syntax - PowerServiceClient host"); System.exit(1); } // Assign security manager if( System.getSecurityManager() == null) { System.setSecurityManager ( new RMISecurityManager() ); } //Call registry for PowerService PowerService service = (PowerService) Naming.lookup ("rmi://" + args[0] + "/PowerService"); DataInputStream din = new DataInputStream( System.in); for (;;) { System.out.println("1 - Calculate square"); System.out.println ("2 - Calculate power"); System.out.println ("3 - Exit"); System.out.println(); System.out.print("Choice : " ); String line = din.readLine(); Integer choice = new Integer(line); int value = choice.intValue();
60
switch (value){ case 1: System.out.print("Number :");– line = din.readLine();System.out.println(); choice = new Integer (line); value = choice.intValue(); //Call remote method System.out.println ("Answer : " + service.square(value)); break;case 2: System.out.print( "Number :"); line = din.readLine(); choice = new Integer (line); value = choice.intValue(); System.out.print( "Power : " ); line = din.readLine(); choice = new Integer (line); int power = choice.intValue(); //Call remote method System.out.println ("Answer : " + service.power(value, power)); break;case 3: System.exit(0); default: System.out.println ("Invalid option"); break; (Reilly, 5-6)
In order to run the client and the server, you can download all the
source and class files together into a .Zip file. Unpack the files into a
directory, and then perform the following steps:
1. Start the rmiregistry
(To start the registry, Windows users should type in the
following: Start rmiregistry, into the run window in the Start
menu)
2. Compile the server
61
Compile the server and use the rmic tool to create stub files.
3. Start the server
From the directory in which the classes are located, type in
the following:
Java PowerServiceServer
4. Start the client
Specify the hostname of the machine where you are running
the server:
Java PowerServiceClient localhost
By now, looking at all of this programming, a person could become
quite overwhelmed. The thing to remember is that Java is that
wonderful technological advantage over other programming
languages, write-once and use over and over. For a more detailed
discussion of how and why to implement an RMI Interface, Client and
Server go to www.Javacoffeebreak.com.
Conclusion
As you can see from the examples and information presented
about JSP, ColdFusion, JAMBA, Jini and RMI, not to mention CORBA, ASP
and the myriad other entities within J2EE, this is a very complex
subject to digest. With the information imparted here into the sections
of J2EE that we have delved, we have only begun to scratch the
surface of the immensity of this subject. J2EE is a program with the
potential for high performance, scalability, availability and openness
62
that has received a very warm welcome from the e-commerce/e-
business community. It does not, however, come without strings
attached.
The JavaBeans, Java servlets and JavaServer Pages components
are all an integral portion of this program and with that in mind, you
must also remember, if there is a problem that develops within any
one of them it can be potentially crippling to the entire business.
The following diagram shows the J2EE architecture.
Within all of these sections, there are smaller segments that
represent the client and the thousands of other programs that the
business relies on to keep them running, current and error-free. The
monitoring of such a program in and of itself can be a daunting task,
add to that the debugging that could be required to investigate any
problems that may arise and one can only imagine the lifetime supply
of aspirin and ulcer soothing medications that may be necessary just to
keep the staff on top of the resolution of any problems.
63
Works Cited
Ahmed, K. & Umrysh, C. Develping Enterprise Java Applications With J2EE and UML. Indianapolis: Addison-Wesley, 2002.
Annunziato, Stephanie. “JSP: Creating Dynamic Forms,” 26 November 2002. <http://www.developer.com/lang/article.php/729421>.
ClaBen, Michael. “About Enhydra XMLC.” XMLC Project. 24 November 2002. <http://xmlc.enhydra.org/project/aboutProject/index.html>.
Clark, Scott. “Visual Java Development Tools,” Web Developer Magazine,January/February 1997.< http://www.webdeveloper.com/java/java_visual_javatools.html>.
Cohen, Peter . “Lutris brings Java application server to OS X.” 11 Mar 2002. MacCentral. 28 Sept 2002. < http://maccentral.macworld.com/news/0203/11.lutris.php>.
“ColdFusion MX for J2EE.” Macromedia.com. 2002. <http://www.macromedia.com/desdev/logged_in/thale_cf_j2ee.html>.
Crawford, David, et al. The Cold Fusion Web Database Construction Kit. 2002. <http://docs.rinet.ru:8083/Cold/fm/fm.htm#Heading6>. <http://docs.rinet.ru:8083/Cold/ch01/ch01.htm>. <http://docs.rinet.ru:8083/Cold/ch02/ch02.htm>.
64
<http://docs.rinet.ru:8083/Cold/ch03/ch03.htm>. <http://docs.rinet.ru:8083/Cold/apa/apa.htm>.
Dawson, Vicky. “Jamba 2.0,” June 5, 1999. <http://the-internet-eye.com/reviews/june99/jamba/default.htm>.
Day, B. “The state of Jini technology,” 1999. <http://www.javaworld.com/javaone99/j1-99-jini_p.html>.
Deitel, Harvey & Paul. “Java; How to Program?” Prentice-Hall, 2002. Pg. 18. (October 3, 2002),
“Development of the JSP/Servlet Platform.” Online.Wysiwyg://36/http://www.javaskyline.com/learnjsp.html (September 26,
2002).“Dynamically Generated Web Content.” Online. <http://java.sun.com/products/jsp/ (September 24, 2002)>.
“Dynamically generating HTML pages with XMLC.” Webreference.com. 24 November 2002. <http://www.webreference.com/xml/column23/>.
“Dynamically Generated Web Content,” Java.sun.com. 26 November 2002. <http://java.sun.com/products/jsp>.
Forta, Ben. “About ColdFusion.” Forta.com. 2002. <http://www.forta.com/cf/>.
Forta, Ben. “Who’s Using ColdFusion?” Forta.com. 2002. <http://www.forta.com/cf/using/list.cfm?highlight=1>.
Hawkins, George C. “How Lutris betrayed the Open Source Community”. Sept 2001. Tripod. 28 Sept 2002. < http://instantdb.tripod.com/>.
Hashman, Steve and Knudsen, Steven, “The Application of Jini[Tm],” December, 2001.<http://www.psiNaptic.com/jini/technology/overview.html>.
“Introduction To Java Servers,” Java Skyline: Java Servlet / Server Headline News, 24 Sept 2002. <http://www.javaskyline.com/learning.html>.
“Interleaf Receives Best-In-Class Awards for Jamba Business/Technology Editors,” Business Wire, August 04, 1998. <http://industry.java.sun.com/javanews/stories/print/0,1797,2832,00.html>.
“Jamba Multimedia Authoring for Java,” Independent Web Review, 1997.<http://www.webreviews.com/97_04/jamba.html>.
“Java Development Using Jamba,” Developing Distributed Application, 1998.
65
<http://hammock.ifas.ufl.edu/techno/ORLANDO98/jamba.htm>.
“Java 2 Platform, Enterprise Edition (J2EE).” Java.sun.com. 6 December 2002. <http://java.sun.com/j2ee.overview.html>.
“Java Remote Method Invocation (RMI).” SUN.com. Sun Microsystems, Inc. 28 Sept 2002. < http://java.sun.com/products/jdk/rmi/>.
“Java RMI over IIOP.” Java2 Platform, Enterprise Edition. 15 November 2002. <http://java.sun.com/products/rmi-iiop/index.html>.
“Java Server Faces Technology,” 24 September 2002. <http://java.sun.com/j2ee/javaserverfaces/index.html>.
“Java Server Pages: Dynamically Generated Web Content,” 26 November 2002. <http://www.java.sun.com>.
“Java server maker Lutris bows out.” Itworld.com. 8 May 2002. IT World. 6 Oct 2002. <http://www.itworld.com/Comp/1361/020508lutris/pfindex.html>.
“Java Server Pages (JSP) 1.0.” 26 November 2002. <http://www.apl.jhu.edu/~hall/java/Servlet-tutorial/Servlet-Tutorial-JSP.html>.
Javaworld, “Jini: New technology for a networked world,” 1999. <http://www.javaworld.com/javaworld/jw-o6-1999/jw-06jiniology_p.html>.
JGuru. “Fundamentals of RMI Short Course.” Java.sun.com. 6 December 2002. <http://developer.java.sun.com/developer/onlineTraining/rmi/RMI.html>
“Lesson: Jamba Quick Start,” <http://www.uwasa.fi/~mj/mmp/JAMBADOC/1jach005.htm>.
“Lutris Enhydra 3.5, the Most Comprehensive JAVA/XML Application Server for Wired and Wireless Devices, Released to Manufacturing.” Business Wire. 8 Dec 2000. Business/Technology Editors. 28 Sept 2002.< http://www.businesswire.com/webb/w0023532140>.
“Macromedia ColdFusion MX for J2EE Application Servers.”Macromedia.com. 2002. <http://www.macromedia.com/software/coldfusion/productinfo/product_overview/>.
“Macromedia JDJStore.com.” Macromedia.com. 2002. <http://www.macromedia.com/buy/>.
McCalmont, Stephen. “The Need for Monitoring and Management of J2EE
66
Application Server Environments.” 17 Jun 2002. e-serv.ebizq.net. 28 Sept 2002. < http://e-serv.ebizq.net/aps/mccalmont_1.html>.
Mohnike, Charles. “ColdFusion Tutorial – Lesson 1-3.” Hotwired.Lycos.com. 2002. <http://hotwired.lycos.com/webmonkey/99/03/index2a.html>.
Pandonia, “Overview of Jini,” 2000. <http://pandonia.Canberra.edu.au/java/jinni/tutorial/overview.html>
Pekowsky, L., Snee, T. & Woods, D. The Developers Guide to the Java Web Server: Building Effective and Scalable Server-Side Applications. Reading: Addison Wesley Longman, Inc., 1999.
Perrone, P. “Jini In The Box,” November 1999. Vol.12, num12; pp55-64
Raj, Gopalan Suresh “A Detailed Comparison of CORBA, DCOM and JAVA/RMI”. 28 Sept 2002. execpc. <http://my.execpc.com/~gopalan/misc/compare.html>.
Reilly, David. “Introduction to Java RMI.” Javacoffeebreak. 15 November 2002. <http://www.javacoffeebreak.com/articles/javarmi/javarmi.html>.
Scannell, Ed, Sullivan, Tom. “IBM, Sun court Macromedia.” InfoWorld. Lead with Knowledge. April 29, 2002. <http://staging.infoworld.com/articles/hn/xml/02/04/29/020429hnibmmacro.xml>.
“The Easiest Java Creation Tool on the Market,” InterLeaf Jamba, 1998.<http://www.networldwide.com/vends/java/jamba_sentry3o.htm>.
“The Power Behind the Server.” <http://java.sun.com/products/servlet/>. (September 28, 2002).
TheServerSide. 24 November 2002. <http://www2.theserverside.com/resources/articls.jsp?1=XMLCvsJSP>.
Turban, Efraim, et al. Electronic Commerce, A Managerial Perspective, 2002. New Jersey: Prentice Hall, 2002.
Venners, B. “The Jini Vision.” 1999. <http://www.artima.com/jinni/jiniology/visionP.html>.
Venners, B. “Jinin technology, out of the box.” December 1998. <http://www.javaworld.com/jw-12-1998/jw-jbe-jini_p.html>.
Venners, B. “Objects, the Network, and Jini.” 6 September 2002. <http://www.artima.com/jinni/jiniology/introP.html>.
67
“Why you Need to Look at the J2EE Connector Architecture in 2001.” Stolker, Theo. June 18, 2001. E-serv.ebizq.net. 6 Oct 2002. <http://e-serv.ebizq.net/aps/stolker_1.html >.
Yager, Tom. “A Striking Balance.” InfoWorld. Lead with Knowledge. (April 29, 2002). <http://staging.infoworld.com/articles/ap/xml/02/04/29/020429apmacro.xml>.
Young, David H. “A Friendly Game of Tug of War: XMLC vs JSP.” April 2002.<http://www.theserverside.com/resources/article.jsp?l=XMLCvsJSP>.
68
Top Related