CA2550051A1

CA2550051A1 - A system and method for hosting a multi-tier application using a direction module

Info

Publication number: CA2550051A1
Application number: CA002550051A
Authority: CA
Inventors: Lenny Hon; Ken Schneider
Original assignee: Lenny Hon; Ken Schneider; Bce Emergis Inc.; Emergis Inc.
Current assignee: Emergis Inc
Priority date: 2003-12-19
Filing date: 2004-12-17
Publication date: 2005-06-30
Anticipated expiration: 2024-12-17
Also published as: KR20070008542A; AU2004298636A1; CA2550051C; US20090144759A1; BRPI0417822A; US7389517B2; US8321879B2; AU2004298636B2; CN1914594A; MXPA06007053A; US20050138650A1; WO2005059739A1; KR101145476B1; US20130067321A1

Abstract

A multi-tier application for interaction with a user interface, such as a browser on a PC or PDA. The application comprises a presentation tier (such as a web server with a JSP/servlet engine) and a business logic tier (such as an application-server) to manipulate data for subsequent presentation on the user interface. A direction module has a plurality of coupled directions, including a function direction to direct a corresponding functional component to perform a data processing function using the business logic tier and provide a data processing output, and a presentation direction to direct a corresponding presentation component to incorporate the data processing output, when applicable, into a presentation template to produce a presentation element for the user interface. The function component and presentation component are independent and separate from each other, the connection being the function component produces the data and the presentation component consumes the output data. The presentation component is an abstract representation of a general kind of presentation element, each specific presentation element having its layout and format (such as markup language) stored in a different presentation template, and the reference to a specific presentation template for the presentation component can be determined at processing time in the presentation tier.

Description

METHOD AND SYSTEM FOR CREATING AND PROVIDING A MULTI-TIER
NETWORKED SERVICE
The present invention relates to a method and system for creating and providing a mufti-tier networked service.
BACKGROUND OF THE INVENTION
[0001] Internet or web based client applications for delivering a networked service generally have two main components. The first is the "loolc and feel" component of the client application.
The second component is the client's application functionality. The "loolc and feel" has traditionally been the purview of a web designer, who has the requisite skills to prepare and create the presentation elements of the application. The client application's functionality traditionally has been handled by a web developer, who creates, implements and assembles the functional elements of the client application.

[0002] The presentation and functional elements of a client application are normally incoipor ated in the same application files, the result being that designers and developers work on the same file. There are several potential disadvantages associated with this approach. For example, if any element of the client application (presentation or function) is changed, then the whole client application client may have to be recompiled. Also, there may be potential problems relating to version control, duplication of work, and client application extensibility.

[0003] The advent of Java and Java Server Pages remedied some of these problems. A Java Server Page in conjunction with Java Beans or enterprise Java Beans permitted many of the functional elements of a client application to be separated from the presentation elements, thereby 1 permitting the developer to create and modify the functional units (e.g., java beans) while freeing the 2 presentation elements of the java server page to the web designer. This approach, however, 3 continues to suffer from many of the same drawbacks as the traditional client application approach.

4 . If a presentation or functional element changed, then it may be necessary to amend and possibly recreate the Java Server Page. Since the Java Server Page still includes both functional and 6 presentation elements, there also remains the potential problems of version control and work 7 duplication.

9 [0004] It is an object of the present invention to provide a mufti-tier application to obviate or mitigate at least some of the above presented disadvantages.

14 [0005] The presentation and functional elements of a client application are normally incorporated in the same application files, the result being that designers and developers work on the 16 same file. There are several potential disadvantages associated with this approach. For example, if 17 any element of the client application (presentation or function) is changed, then the whole client 18 application client may have to be recompiled. Also, there may be potential problems relating to 19 version control, duplication of work, and client application extensibility.
Contrary to present client applications, there is prow ided a anulti-tier application for interaction with a user interface, such as a 21 browser on a PC or PDA. The application comprises a presentation tier (such as a web server with a 22 JSP/servlet engine) and a business logic tier (such as an application server) to manipulate data for 23 subsequent presentation on the user interface. A direction module has a plurality of coupled 24 directions, including a function direction to direct a corresponding functional component to perform a data processing function using the business logic tier and provide a data processing output, and a 26 presentation direction to direct a corresponding presentation component to incorporate the data 27 processing output, when applicable, into a presentation teanplate to prod~.ice a presentation element 28 for the user interface. The function component and presentation component are independent ar~d _. 2 _ 1 separate from each other, the connection being the function component produces the data and the 2 presentation component consumes the output data. The presentation component is an abstract 3 representation of a general kind of presentation element, each specific presentation element having 4 its layout and format (such as markup language) stored in a different presentation template, and the reference to a specific presentation template for the presentation component can be determined at 6 processing time in the presentation tier.
7 [0006] According to the present invention, there is provided a method for hosting a computer executable multi-tier application for interaction over a network with a user interface, the application 9 including an application presentation tier. The method comprises the steps of selecting a first presentation template, the first template including a first presentation instruction for defining a 11 corresponding first presentation element; selecting a first presentation component of the application 12 presentation tier for processing the first presentation instruction; and linking the first presentation 13 component to the first template, wherein the first component processes the first presentation 14 instnzction and generates the fir st presentation element during execution of the mufti-tier application for subsequent delivery to the user interface.
16 [0007] The method comprises the additional steps of selecting a second presentation template, 17 the second template including a second presentation instnzction for defining a corresponding second 18 presentation element; selecting the first presentation component for processing the second 19 presentation instruction; and linking the first component to the second template; wherein the first component processes the second presentation instruction and generates the second presentation 21 element during execution of the mufti-tier application for subsequent delivery to the user interface.
22 [0008] In a preferred embodiment, the presentation templates are computer readable files of a 23 file system and the presentation instz~uctions are selected from the group comprising: layout, style 24 and format of the first presentation element. In a fuz~ther embodiment, the pr esentation instructioxis are written in a markup language selected from the group comprising: I~TML, ZTDML and 'WML.

1 [0009] The first presentation component is a computer executable file. In a preferred 2 embodiment, the computer executable file is a java bean.
3 [0010] The method may also include an application logic tier and the additional steps of 4 selecting an input datum; selecting a first function component of the application logic tier for processing the input datum; linking the input datum to the first function component, wherein the first 6 function component processes the input datum and generates an output datum during execution of 7 the multi-tier application; directing the first presentation component to process .an output data 8 presentation instruction for further defining the corresponding first presentation element to include 9 the output datum, wherein the first presentation component processes the output datum presentation instruction and generates the first presentation element incorporating the output datum during 11 execution of the multi-tier application.
12 [0011] The first function component is a computer executable file. In a preferred embodiment, 13 the computer executable file is a j ava bean.
14 [0012] The present invention also provides a system for hosting a computer executable multi-tier application for interaction over a net vork with a user interface, the application including an 16 application presentation tier. The system comprises a first presentation template, the first template 17 including a first presentation instruction for defining a corresponding first presentation element; a 18 first presentation component of the application presentation tier for processing the first presentation 19 instruction; and, a first direction element for linking the first presentation component to the first template; wherein the first component processes the first presentation instruction and generates the 21 first presentation element during execution of the multi-tier application for subsequent delivery to 22 the user interface.
23 [0013] The system may also include a second presentation template, the second template 24 inch~ding a second presentation instruction for defining a co~-rospending second presentation element; arid a second direction element for linking the first component to the second template, 26 wherein tlae ~~°st component processes the second presentation instruction and generates the second 1 presentation element during execution of the mufti-tier application for-subsequent delivery to the 2 user interface.
3 [0014) The system may further include a first function component of the application logic tier 4 for processir.~g an input datum; and, the first direction element further linking the input datum to the first function component, wherein tl~e first function component processes the input datum and 6 generates an output datum during execution of the mufti-tier application. An output data 7 presentation instruction further defines the corresponding first presentation element to include the 8 output datum.

BRIEF DESCRIPTION OF THE DRAWINGS

12 [0015] These and other features of the preferred embodiments of the invention will become 13 more apparent in the following detailed description in which reference is made to the appended 14 drawings wherein:
[0016] Figure 1 is a schematic view of a system according to an embodiment of the present 16 invention;
17 [0017] Figure 2 is an expanded schematic view of the system of Figure 1;
18 [0018] Figure 3 is a schematic view of the steps in processing a requested resource according 19 to an embodiment of the present invention;
[0019] Figure 4 is a schematic view of the elements within each tier of a mufti-tier application 21 according to an embodiment of the present invention;
22 [0020] Figure 5 is a schematic view of an alternate embodiment of the system of Figure l;
23 [0021) Figure 6(a) i.s a schematic illustration of a Java Server Page;
_5_ 1 [0022) Figure 6(b) is a schematic illustration of a Java Server Page according to an 2 embodiment of the present invention;
3 [0023] Figure 7 is a logical view of a function component according to an embodiment of the 4 present invention;
[0024] Figure 8(a) is a schematic illustration of a static presentation component according to 6 an embodiment of the present invention;
[0025] Figure 8(b) is a schematic illustration of a dynamic presentation component according 8 to an embodiment of the present invention;
9 [0026] Figure 9 is a schematic illustration of the output of a processing a Java Server Page , according to an embodiment of the present invention;
11 [0027] Figure 10 is a logical viewof a client application using a Java Server Page according 12 to an embodiment of the present invention;
13 [0028] Figure 11 is a logical view of a processing step of a client application according to the 14 present invention;
[0029] Figure 12 is a schematic view of the output of a processing step of a client application 16 according to an embodiment of the present invention;
17 [0030] Figure 13 is an expanded schematic view of the system and the processed outputs of 18 the client application illustrated according to an embodiment of the present invention;
19 [0031] Figure 1~1. is a schematic view of the elements of a client application and associated system according to an embodiment of the present invention;
21 [0032] Figure 15 is a, flowchart illustrating the steps in a method according to an embodiment 22 of the present invention;

1 [0033] Figure 16 is a flowchart illustrating further steps in the method of Figure 15 according 2 to an embodiment ofthe present invention;
3 [0034] Figure 17 is a flowchart illustrating alternate further steps in the method of Figure 15 4 according to an embodiment of the present invention; and, [0035] Figure 1 ~ is a flowchart illustrating further steps in the method of Figure 17 according 6 to an embodiment of the present invention.

9 [0036] Referring to Figure 1, a schematic view of a system 10 is illustrated. The system 10 is a computing network as is known to those skilled in the ant. An individual operating a network 11 terminal 11 may access a remotely located resource via a communications network 13. The 12 communications network 13 maybe the Internet, the World Wide Web, a LAN, WAN, VPN.
13 [0037] The network terminal 11 rnay be any network appliance known to those skilled in the art, 14 which includes means to communicate with the remotely located resource and means to transmit a request via the communications network 13: a personal computer, lap top computer, palm top 16 computer, hand held device, wireless text messenger cell phone, etc.
17 [0038] The remotely located resource may be a web page located on a web server 15 or data that 1~ is located in a database 17, which is accessed by an application server 19 (via database server 119) 19 that is connected to (or in communication with) the web server 15.
[0039] Alternately, the application server 19 and associated database 17 may be accessed 21 directly over the communications network 13, without the need of the web server 15. For example, 22 an individual operating a personal computer (i.e. terminal 11) may access a remotely located 23 resource via the Internet (i. e. communications network 13) if the personal computer includes meaals 24 for communicating via the ~aetwork 13 (e.g. a modern) and executable software fox sending a requesi for the resource to the resource Host.

1 [0040] The remotely located resource may be as simple as static HTML
document. Alternately, 2 the requested resource may comprise a small portion of a larger service, such as completing an 3 online transaction, which requires the production of several responses that are particular to the given 4 user's current session. The data included in these transactions are dynamic, not static; i.e., they are generated in response to the user's particular request. The requested data may reside in the database 6 17, which is accessible by the application server 19 via database server 119. The user may simply 7 require the raw data, or the data may be processed and the processed result is incorporated in the 8 response to the user's request. There are several ways by which the requested data may be processed 9 and or incorporated into a response.
(0041] Refernng to Figure 2, an expanded schematic view of the system 10 illustrates one such 11 way in which a request may be processed, which employs java web server and java server page 12 (JSP) technology. The web server 15 includes a java server page engine 21 and a servlet engine 23, 13 which together process the requested resource (i.e. JSP 25) and generate a response that is returned 14 to the terminal 11.
[0042] Figure 3 illustrates schematically an expanded view of the requested resource 25 and the 16 generated response, a data output 27. A user operating the terminal 11 requests a remotely located 17 resource (the java server page 25) via the communications network 13. The web server 15 running 18 the JSP engine 21 receives the resource request and retrieves the requested j ava server page 25, reads 19 it and translates the JSP elements in to Java code 29 (.Java). The java code translation 29 is then compiled into a java servlet 31 (.class) using a standard compiler as is known to those skilled in the 21 art. Next, the servlet 31 is executed using a standard API, such as servlet engine 23. As the servlet 22 runs, it processes input data 33 and generates the data output 27; i.e., it processes the request and 23 generates a response. The output 27 is then directed to the temninal 11 via the network 13.
24 [0043] Referring to Figures 4 and 13, a system for hosting a computer executable mufti-tier application 191 for interaction over a network with a user interface 1 l, the application 191 including 26 an application presentation tier 171 and an. application logic tier 181, and associated elements are 2~ illustrated according to a pr°eferred embodiment of the present invention. The system comprises a _g_ 1 first presentation template 65, the first template including a first presentation instruction for defining 2 a corresponding first presentation element or output 79; a first presentation component 61 of the 3 application presentation tier 171 for processing the first presentation instruction; and, a first 4 direction element 161 for linking the first presentation component 161 to the first template 65, wherein the first component 161 processes the first presentation instruction and generates the first 6 presentation element during execution of the mufti-tier application for subsequent delivery to the 7 user interface 11.
8 (0044] In a preferred embodiment, the system comprises a second presentation template 67, the 9 second template 67 including a second presentation instruction for defining a corresponding second presentation element or output 79; and, a second direction element for linking the first presentation 11 component 161 to the second template 67, wherein the first component 161 processes the second 12 presentation instruction and generates the second presentation element or output 79 during execution 13 of the mufti-tier application for subsequent delivery to the user interface 11.
14 [004] In a still further embodiment, the system comprises a first function component 59 of the application logic tier 181 for processing an input datum 33; and, the first direction element further 16 linl~ing the ix~put datum 33 to the first function component 59, wherein the first function component 17 processes the input datum 33 and generates an output datum 27 during execution of the mufti-tier 18 application. An output data presentation instruction further defines the corresponding first 19 presentation element or output to include the output datum 27.
[0046] Referring to Figures ~. and 15, a flowchart of a method for hosting a computer executable 21 mufti-tier application 191 for interaction over a network with a user interface, the application 191 22 including an application presentation tier 171, is illustrated according to a preferred embodiment of 23 the present invention. The method comprises the steps of selecting a first presentation template, 65 24 the first template 64 including a first presentation inst~.-izction for defining a corresponding first presentation element (step 100); selecting a. first presentation component 161 of the application 26 presentation tier 171 for processing the first presentation instruction (step 200); and, linking the first 27 presentation conaponent to the :first template 65 (step 300), wherein the first component 161 _g_ 1 processes the first presentation instruction and generates the first presentation element or output 79 2 ~ during execution of the multi-tier application for subsequent delivery to the user interface.
3 (0047] Referring to Figures 4 and 16, a flowchart.of the additional steps of the method of figure 4 15 is illustrated. The steps further comprise: selecting a second presentation template 67, the second template including a second presentation instruction for defining a corresponding second 6 presentation element or output 79 (step 101); selecting the first presentation component 161 for 7 processing the second presentation instruction (step 201); and, linking the first component 161 to the 8 second template 67 (step 301), wherein the first component 161 processes the second presentation 9 instruction and generates the second presentation element or output 79 during execution of the multi-tier application 191 for subsequent delivery to the user interface.
11 (0048] In a preferred embodiment, the presentation templates 65,67 are computer readable files 12 of a file system and the presentation instructions are such as but not limited to: layout, style and 13 format of the first presentation element. In a further embodiment, the presentation instructions are 14 written in a markup language selected from the group comprising such as but not limited to: HTML, HDML and ~7ML.
16 [0049] The first presentation component 161 is a computer executable file.
In a preferred 17 embodiment, the computer executable file is a Java bean.
18 [0050] The first presentation component 161 is linked to the first presentation template 65 by a 19 direction element 57. The direction element 57 specif es the location of the first presentation template 65 and directs the first presentation component 161 to the specified location. In a preferred 21 embodiment, the direction element 57 is a first presentation component tag 57 is such as but not 22 limited to page Tag; control Tag; attribute Tag; produce?aage Tag; clear Tag; and interceptor Tag.
23 [0051] The first presei~.tation component tag 57 is expressed as a directive of a direction module, 24 which implements the tnulti-tier application. In a preferred embodiment, the direction module is a java server page 49.

1 [0052] Refernng to Figures 4 and 17, a flowchart of the additional steps of the method of figure 2 15 is illustrated, wherein the mufti-tier application 191 further includes an application logic tier 181.
3 ~ The steps further comprise selecting an input datum 33 (step ~ 102);
selecting a first function 4 component S9 of the application logic tier 181 for processing the input datum 33 (step 202); and, linking the input datum 33 to the first function component S9 (step 302), wherein the first function 6 component S9 processes the input datum 33 and generates an output datum 27 during execution of 7 the mufti-tier application 191.
8 [0053] Referring to Figures 4 and 18, a flowchart of the additional steps of the method of figure 9 17 is illustrated, wherein the first template further comprises an output data presentation instruction . for further defining the corresponding first presentation element to include the output datum 27. The 11 method comprises the additional step of directing the first presentation component 161 to process 12 the output datum presentation instruction (step 403), wherein the first presentation component 161 13 processes the output datum presentation instruction and generates the first presentation element or 14 output 79 incorporating the output datum 33 during execution of the mufti-tier application 191.
[0054] In a preferred embodiment, the output datum presentation instruction defines a c~ntrol 16 within which the output datum is presented such as but not limited to Text field, Password field, 17 Hidden field, Text area, Table, List box, Checlc box, Radio button, Image, Push button, Image 18 button, Submit button, Reset button, Link and Span.
19 [0055] The first function. component S9 is a computer executable file. In a preferred embodiment, the computer executable file is a Java bean.
21 [0056] The first function component S9 is linced to the input datum 33 by a direction element 22 SS. The direction element SS specifies the location of the input datiun 33 and directs the first 23 function component to the specified location. In a preferred embodiment, the direction element SS is 24 a first function component tag S5 such as but not limited to init Tag; call Tag; prerequisite Tag;
debug Ta.g; error Tag; getValu.e Tag; if Tag.
_11_ 1 [0057] In a preferred embodiment, the first function component tag 55 is expressed as a directive 2 of a direction module, the direction module implementing the multi-tier application. The direction 3 module is a Java server page 49.
4 [0058] F.eferring to Figure 5, a further alternate embodiment of the system 10 is illustrated schematically as application server servlet system 200. The JSP engine 21 resides on the application 6 server 19. The servlet engine 23 cooperates with the JSP engine 21 in the translation, compilation 7 and execution of the Java server page 25. The remotely located resource in the system 200 may 8 include data located on the local database 17, which is accessed directly by the application server 19 9 via database server 119 and processed by the servlet 31. The output in this case is returned to the user via another mechanism, such as e-mail.

12 [0059] Referring to Figure 6(a), a schematic view of a java server page JSP
39 as is known to 13 those skilled in the art is illustrated. The JSP 39 is a text document that contains static template data 14 (which can be expressed in any text based format, such as HTML, WML and XML) and JSP
elements (which are interpreted by the JSP engine 21).
16 [0060] The static content, which defines the look and feel of the processed output, is created by 17 writing those portions of the JSP 39 using markup (ML) statements 43. For example, if HTML is 18 selected as the ML, then the template portions of the JSP are scripted using HTML, statements and 19 syntax.
[0061] The dynamic content is created by accessing the Java programming language object 21 properties. The dynamic elements of the JSP 39 typically include JSP
directives 41, which pass ~22 information to a JSP engine 21, JSP tags 45, which may be implemented as standard tags or 23 customized tags that are used to for example instantiate a Java bean on a server, and scriptlets 47, 24 which are small scripts of java code that perform fianctions not supported by the tags.
[0062] The JSP directives 4~1 may include page directives (which communicate page specific 26 information, such as buffer axed thread inforlxaation or error handling), language directives (which _12_ 1 specify the JSPs scripting language), include directives (which cari be used to include an external 2 document in the page), and taglib directives (which indicate a library of custom tags that the page 3 can invoke). w -° w 4 [0063] The JSP tags 45 are responsible for implementing most of the JSP
processing. These include a number of standard tags (e.g., useBean, setProperty and getProperty). Custom tags may 6 also be designed and implemented for a specific purposes).
7 [0064] Referring to Figure 6(b), a JSP 49 according to a preferred embodiment of the present invention is illustrated. In a preferred embodiment of the present invention, the JSP 49 does not 9 contain any markup language (ML) statements 43,. nor does it include Java scriptlets 47. All operational or functional and presentation elements of the JSP 49 are saved as discrete function 11 components and presentation components, respectively. The components 59 and 61 are accessed 12 via respective custom function component tag extensions 55 and presentation component tag 13 extensions 57, which in turn are specified using a fimction component taglib directive 51 and a 14 presentation component taglib directive 53, respectively.
[006] Thus, the java server pages ~.9, within the architecture of a servlet client application, 16 assembled according to the present invention contain only JSP directives and custom tag extensions 17 55 and 57.

19 [0066] The JSP 49 directives take the following form: <%@directi~eName attribute="value" o>
21 Where:
22 directiveName is the specifzc directive name 23 a t tr mu t a is an attribute for thgs specWc dir active 24 A directive may have zero or more attubutes.
_13_ 1 value is the specific value for the specified attribute 2 An attribute may have exactly one value.

4 The JSP 49 page Directive [0067] In a preferred embodiment, all JSP processing pages 49 begin with the following page 6. directive:
7 <o@ page session="true" buffer="buffer size kb"
8 autoFlush="true"
9 1 isThreadSafe="true" errorPage=".../error.Page.jsp" o>
Where:
11 . .. /errorPage . j sp is the URL to another JSP page that will be invoked 12 if an uncaught runtime exception is thrown 13 If this is an error JSP page, then the following attribute should be 14 included in the page directive: isErrorPage="true"
16 The JSP 49 taglib Directive 1~ [0068] The tagl ib directive specifies custom tag extensions. The following taglib directives 18 are specified in all JSP processing pages 49 (right after the page directive):
19 <o@ taglib uri="/servlet/FCTagsClient.jar" prefix="FC" o>
<o@ taglib uri="/servlet/PCTagsClient.jar" prefix="PC" o>
21 The JSP 49 include Directive 22 [0069] The include directive can be used to insert, inline, the content of another JSP
23 processing page 49:

1 <%@ include file=".../otherPage. jsp" o>
2 Where:
3 ... /o therPage . j sp is the path to another JSF page that will be included.
4 FUNCTION COMPONENTS (FC):
[0070] Referring to Figure 7, a logical view of the function component 59 is illustrated.
6 (0071] The function component 59 is a distinct, independent piece of business functionality.
7 Each function component 59 receives a set of pre-requisite data 33, performs a processing function 8 using the received data 33 and returns a set of result data 27. In a preferred embodiment, every 9 function component 59 exists as a Java class that is based on a generic base class. When a client application requires a function component 59, it is simply instantiated using Java reflection based on 11 the logical name of the function component 59. The function component 59 conforms to the 12 specification of a Java Bean.
13 [0072] T he Public r~.bst~°act Class FC is the generic definition for all function components 59.
14 All specific i~n.ction component 59 classes extend this base class. This abstract class provides a set of built-in functionality inherited by all function component 59 classes as well as defining the set of 16 functionality that must be implemented specifically within the function component 59 class itself.
17 [0073] The Public Class ~~lppl~.cativ~s~atego~~y ~ ~Funetivra.~ s 18 Any given function component 59 is defined further by a specific class that extends the 19 Function Component 59 class.
In a preferred embodiment, the naming convention for a specific function component 59 21 class is {I~.pplicat:i.onCatec~ory~ {Functa.on~ where:
22 ~ {ApplicationCategory-} i~.: a shoat fo:e~n indicating the application category 23 that the functlOn component 59 belongs to (e.g. Qrder for the Net~Order application 1 category, Track for the Net*Track application category, or General for the General 2 application category) 3 ~ { Fune t i on ~ is a short but descriptive phrase indicating the function of this specific 4 function component 59 (e.g. Perf ormProduct Search for a function component 59 that actually performs a search of a catalogue and returns a series of products) 6 Function Component Instances 7 [0074] A function component 59 is instantiated with a function component 59 instance name so that multiple instances can be uniquely named. In a preferred embodiment, the function component 9 59 instance name is:
{ApplicationCategory~{Function~_{InstanceDescription~
11 Where:
12 { Ins t anc eDe s c ript i on } is a short descriptive reference for this specific instance of 13 . the function component 59 14 e.g. OrderPerformProductSearch~OrderEntry Public Method setInstanceDesc~r~.ption ( ) 16 [0075] This method is used to set the instance description for the function component 59. This 17 method is often called immediately after instantiation of the function component 59.
13 Public Method get~nstanceDeserigtion ( ) 19 [0076] This method returns the instance description for the function component 59.
Public Method getTnstance~T~ne ( ) 21 [0077] This method returns the instance name for the function component 59.
22 Pz°ez°~quisit~ data 33 ~tzd l~etu~°~zedl p~spalt a'~ata ?7 1 [0078] In a preferred embodiment, all prerequisite data 33 and returned result data 27 are stored 2 as instance variables. The name of the instance variable is the name of the prerequisite data element 3 itself. In addition there is a set and get method for each of these instance variables which uses the 4 same naming conventions. This allows the prerequisite data 33 to be referenced externally by using Java reflection. For example, if a function component 59 has a prerequisite data element 33 named 6 userlD then there is an instance variable named userlD that is set externally using the public 7 method named s a tUs erID ( ) . In the case where this is also a returned result data 27 element, then 8 the data 27 is returned using the public method ge tUs erID ( ) . In the case of a returned result data 9 element, there is a public get method.
Protected Method validate ( ) 11 [0079] The validate ( ) method is called from within the execute ( ) method, prior to 12 actually executing any processing logic of the function component 59. If there is any missing or 13 incorrectly set prerequisite data 33, then the FC EXCEPTION
PrerequisiteData 14 FCException exception is returned.
Public Method execute ( ) 16 [0080] The execute ( ) method provides the internal processing logic of the function 17 component 59. Prior to performing any specific processing, all of the prerequisite data 33 is 18 validated. As return result data 27 is produced, it is stored into the respective instance variables. If 19 an error occurs during the execution of the processing logic, the appropriate FCException exception is returned.
21 Publac Class FCExceptiQx~
22 [0081 ] This class represents an error that has occurred during either the validation of. prerequisite 23 data 33 or during the exec~.~ti.on of Llae processing logic of a function component 59.
24 Pub~ie ~'~~E~C~;PTIC~~7_wP:~ec~.~.sa.teDat~.
-1%-1 [0082] This exception indicates that the prerequisite data 33 does not conform to the 2 requirements defined by the function component 59 definition. Such an exception is typically 3 caused by an error in the specific call-to the function component 59.
4 Public FC EXCEPTION FCInternal [0083] This exception indicates that there has been an unexpected error during the internal 6 processing logic of the function component 59. Such an exception is typically caused by an error 7 within the function component 59 logic itself.
8 PublicFC EXCEPTION ServerInternal 9 [0084] This exception indicates that there has been an unexpected error during the internal processing logic of the function component 59 involving the call to a server.
Such an exception is 11 typically caused by an error within the function component 59 logic itself or within the server logic.
12 Public FC EXCEPTION Exception 13 [008] This exception indicates that an attempt was made to return an invalid function 14 component exception. ~ The FCExcept ion itself can only return this exception. Such an exception is caused by an error within the function component 59 logic itself.
16 Public FC EXCEPTION Assertion 17 [0086] This exception indicates that an assertion failed.
18 Other Exceptio~zs 19 [0087] The function component ~9 itself can deFme its own function component exception by specifying its own exception id.entif er when the function component exception is constructed. The 21 specific meaning of the exception is defined by the h.~xzction component 59.
22 P~ablie:.~~~th~~ ~etExoept~.e~~~I~ ( ) 1 [0088] This method returns the exception identifier.
2 Public Method getFailureReason ( ) 3 [0089] This method returns the failure reason.
4 Public Method toString ( ) [0090] This method returns a printable version of the exception.
6 FUNCTION COMPONENT (FC) TAG EXTENSIONS:
[0091] The function components 59 are involved using a set of function component tag 8 extensions 55.
9 The function component: init Tai [0092,] This tag initializes the page for function component 59 processing. In a preferred 11 embodiment, this tag is the first function component custom tag on every page where function 12 component custom tags 55 are utilized. This tag has the following format:
13 [<functioncomponent:init classpath="classpath" scope="scope"
14 />]
Where:
16 cl a sspa th is the classpath to search for when instantiating function components 59, 17 scope is the default scope for the storage of function components 59 instantiated on the 18 JSP 49. The scope can be any one of the following values: application, session or 19 request. If the scope is not specified, the default scope is session.
e.p. session 21 Both the classpath attribute and the scope attribute are optional.

1 The function Component : call Tai 2 (0093] This tag 55 defines that a specific function component 59 is to be invoked. This 3 tag has the following format:
4 <functionComponent:c~ll name="functionComponentlnstanceName"
debugLevel = "debugLevel" >
6 dontResetAllData="yes"scope="scope"
7 conditionalExecution="true" >
8 functionComponent-body 9 </functionComponent:call>
Where:
11 func ti onComponen tins tanceNameis the function component 59 instance to invoke.
12 If this function component 59 instance has already been invoked within the current execution 13 of the function, then it is reused. ~therwise this function component 59 instance is created.
14 e.g. OrderG~et OrderEntry debugLevel is the debug level for this specific function component 59 call, specified as 16 high, medium or low 17 dontReset~.llData specifies that the resetAllData ( ) method of the function 18 compon ent fig will rot be called. Nonnallythe resetAllData ( ) method ofthe function 19 component 59 will always be called prior to the setting of any prerequisite data 33 for this function component call. The resetAllData ( ) method can act differently than simply 21 using the empty attribute on all prerequisite data 33. For numeric values, using the empty 22 attribute sets these values to 0 whereas the resetAllData ( ) method may in fact cause 23 these vahaes to be set to some default value other than 0. The function component 59 defines 24 the specific behaviour ofthe resetAllData ( ) method. When an function component 59 has multiple optional prerequisite data 33 elements and the function component 59 is used 26 more than once in a session, it may be desirable to reset all prerequisite data 33 on a 27 subsequent call. However there may be a case whexe this is not the desired.
behaviour. This 28 behaviour can be overridden using tlae dontReseLAllData attribute.
29 scope is the scope for the storage of this function component.59 (which.
overrides the setting for the page defined in the funs tionComponcnt : lnit tag). Tl~e scope can be _20_ 1 any one of the following values: function, session or request. If not specified, the scope is 2 defined by thefunctionComponent:inittag.
3 e.g. session 4 conditionalExecution="true"this attribute indicates that the executionofthistag 55 is conditional upon the enclosing functionComponent : if tag currently having a 6 true value 7 This tag 55 contains a body that include functionComponent : prerequisite and 8 funct ionComponent : error tags as required. Only the name attribute is mandatory.
9 Returned result data 27 is accessible through a dataRef erence specification.
The functionComponent:prerequisite Tai 11 [0094] This tag 55 defines one prerequisite data element 33 for the function component 59. This 12 tag 55 must be defined within the body of a funct ionComponent : cal l tag.
This tag 55 has 13 the following format:
14 <functionComponent:prerequisitetarget="prerequisit:eDataReferen ce" .
16 value="literalValue"source="dataReference"optSource="dataRefer 17 ence" empty="booleanValue" />
18 Where:
19 .prerequi si t eDa taRef eren ceis either the simple name of a prerequisite data element 33 of the function component 59 or else a reference to a data element of a prerequisite data 21 element of the function component. In a preferred embodiment, the prerequisite data 22 reference begins with a reference to a prerequisite data element 33 of the function component 23 59.
24 If the target is simply the prerequisite data element 33 itself, then the reference is just the name of the data element (e.g. ordered).
26 If the pz~erequisite data element 33 is a structure, the21 the reference is the name of the data 27 element structure, a dot (6.') and the element name of the structure. (If the element is itself a 28 structure, then it can also be further qualified..) (e.g. userAttributes .
firstlname).

1 1 i t eral Val a a is a hard-coded literal value 2 da taReference is a reference to dynamic data, The reference to dynamic data follows the 3 same specification as defined for data reference value for control tags.
4 booleanValue is either true or false In a preferred embodiment, all of the attributes are mandatory except that only one of value 6 or source or optSource or empty maybe specified. If optSource is specified, 7 then the dataReference can be a non-existent data reference.
If empt y="t rue" is specified, then an appropriate value is passed to the set method. For a 9 String attribute, an empty string is passed (i.e. ""). For numeric attributes, a zero (i.e. 0) is passed. For object attributes, a null object is passed (i.e. null).
11 The functior:.Componer:.t : debug Tai 12 [0095] This tag SS defines various debug information that can help with debugging JSP pages.
13 In a preferred embodiment, the tag 55 has the following format:
14 <functionComponent:debugdebugZevel="debugLevel"debugFile="debu gFi 1 e"
16 value="literal Value" source="dataReference" />
17 Where:
1S debugLevel is the default debug leV~el for all function components 59, specified as high, 19 medium or low debugFile is the path to the file that will be used for debug output (In a preferred 21 embodiment, the first time a debug file specification is encountered, that hle is opened for 22 appending. All subsequent debug file occurrences are ignored. If no debug file is specified 23 then debug output goes to the Sys t em . out stream.) 24 li teral Value is a hard-coded literal value da taReference is a reference to dynamic data9 the reference to dynamic data follows the 26 , same specification as defined for data reference 'value for control tags.
_ 22 ..

1 All ofthe attributes are optional however only one ofvalue or source maybe specified.
2 The order of precedence is order followed by value.
3 The functionComponent : error Tai 4 [0096) This tag defines the handling for one type of error for the function component 59. This tag must be defined within the body of a functionComponent : call tag. This tag has the 6 following format:
7 <functionComponent:errorname="errorDescript:or"page=".../errorPag 8 e. jsp" />
9 Where:
errorDescriptoris a string that identifies a specific function component exception; e.g.
11 PasswordMismatch. The function component 59 itself defines the meaning of a 12 particular function component exception. The special value of"*" represents any exception 13 (i.e. a default exception handler).
14 ... /errorPage . j sp is the URL to another J8P page 49 that will be invoked if the specified runtime error occurs. The exception is available in the script variable 16 funetionComponentExeeptionwithintheerrorpage.Iftheerrorpageisspecifiedas 17 the special value "ignore" then the exception is ignored. The error page can either be a 18 specific value or a data reference. The reference to dynamic data follows the same 19 specification as defined for data reference value for control tags.
In a preferred embodiment, all of the attributes are mandatory.
21~ The functionComponent : getVa~ue Tag 22 [0097] This tag is used to set a script vaa-iable with the value of a returned result data element of 23 an function component. This tag has the following format:
24 <functionComponent:getValuesource="dataReference"optSource=°'da taReference" />
26 Where:

1 da taReference is a reference to dynamic data. The reference to dynamic data follows 2 the same specification as defined for data reference value for control tags.
3 In a preferred. embodiment, all of the attributes are mandatory except that only one of 4 source and optsource may be specified. If optSource is specified, then the da taReference can be a non-existent data reference.
6 The script variable re sul t Value is set with the value of the specified returned result data 7 element.
8 ThefunctionComponent:if Tai 9 [0098] This tag is used to conditionally execute other tag calls and to conditionally generate ML
output. This tag has the following format:
11 <functionComponent:if >
12 conditional-functionComponent-body 13 </functionComponent:if>
14 This tag acts as an IF-THEN block. ML output generated from tags within this block is included only if the value of the func tionComponent : if block is true at the end of 16 the block. The value of the block is initialized to false at the start of the block. The value of 17 the block is set by calling the following Java method:
18 FunctionComponentIfTag.setTfValue (PageContext pageContext, 19. Boolean ifValue) [0099] Normally the setl fValue ( ) method would be called from within the execute ( ) 21 method of an function component invoked by a f unc t i onComponent : c al ltag inside the block 22 of the f unc t i onComponent : i f tag. It is possible to call the s et I f Val ue ( ) method multiple 23 times within the same block. However, it is the last call that d.eteimines the final setting for 'the 24 bloclc that is used to deci de whether or not ML output generated v~,ithin the block should be included in the generated output page.
_24_ 1 [00100] In addition, it is possible to conditionally execute various tags within the 2 funetionComponent : if block. If a tag contains the attribute 3 conditionalExecute="true" then that tag is only executed if the ctuTent value of the 4 functionComponent : if block is ~ true. The following ~ tags 55 support the conditionalExecute attribute: functionComponent : call, 6 presentation:control,presentation:producePage TheconditionalExecute 7 attribute can be added to other tags as required. It is possible to build a logical "AND" condition for S a functionComponent : if block using theconditionalExecuteattribute. Suppose there 9 is a function component 59 named "SetlfllalueFunctionComponent" that takes the prerequisite data 33 and determines whether or not to call the FunctionComponentlfTag.
setlfValue ( ) 11 method. We can use the functionComponent : call tag to invoke this function component 12 twice at the beginning of the functionComponent : if block. On the second 13 functionComponent : call we include the conditionalExecute attribute. This 14 effectively makes the value of the functionComponent : if block the value of the first Setlfl~alueFu~actio~zConaponent sell 'AND'ed with the value of the second 16 SetIfT~cclueFunctiotrCompotaent call.
17 PRE~ENTA,T~t~N r~'EMPIJATE~ ~~'°~'):
1~ [00101] Referring to Figures 8 (a) and (b) and 9, the presentation template (PT) 61 is illustrated 19 schematically according to a preferred embodiment of the present invention.
A set of PT 61 files defines the "look and feel" of a client application, each PT 61 consisting of a series of ML
21 statements that defines a template for a presentation element or output page 79 or portion of an 22 output page 79 of the client application. The set of PT 61 fzles for the client application are language 23 (e.g., French, English) and format (e.g., HT ML, HDML) specific.
24 [00102] In a. prefers ed ernl~odi3~aent, the PT 6I files take one of two forrxis. Referring to Figure 8(a), a first or static PT 65 is illt~st:rated. The static PT 65 consists solely of ML statements that 26 define the presentation elements of the output page 79 or portions thereof As the 3SP 49 is _25_ 1 processed, the ML statements of the static PT 65 are used to define a static portion of the output page 2 79, such as the header or footer; i.e., those portions of the output page 79 that are common to all 3 output pages of the client application.
4 [00103] F,eferring to Figures 7 and 8(b), a second or dynamic PT 67 is illustrated. The dynamic PT 67 consists of ML statements that define the. presentation elements of the output page 79 or 6 portion of the output page 79. It also includes at least one control 63, which provides a link to the 7 data output 27 that is generated by the FC 59. As the JSP 49 is processed, the ML statements of the 8 dynamic PT 67 defines an output that incorporates the data output 27 of the FC 59. For example, the 9 output page 79 or portion thereof may display the order details of a purchase order (e.g., a list of items purchased) in a table. The data output of the FC 59 may be the list of items purchased, which 11 are displayed in an HTML table (i.e., control 63) having a presentation format defined by the PT 67.
12 [00104] In a preferred embodiment, a well-defined hierarchical file organization is used for the 13 deployment of presentation template files. The hierarchy consists of the following levels, in order:
14 ~ Application root - This is the root of the hierarchy for this specific application.
~ Format - This level organizes files by format (e.g. divisions of html, hdml).
16 ~ Language - This level organizes files by language locale (e.g. divisions of en US, 17 en CA, fr CA).
18 ~ Aplalication specific levels) - This (these) levels) may be defined as required for the 19 specific application.
[00105] The individual presentation template files 61 are located within the application specific 21 levels) if they are specified or else they are located within the language level.
22 [00106] In a preferred embodiment, the common elements of the "look and feel" are segmented 23 into separate presentation template files 61. For example, if sll the pages of an application have a 24 common header and common footoz~, then each of these sections should be extracted into their own files respectively so that t hey can be "included" by reference rather than having their contents copied 26 in all of the pages of ~tho applicatia~a. Accordingly, it is recognized that the couz-ier template files 61 _26_ 1 and associated FC tags 59 and PC tags 57 can be reused to generate the pages of the application. For 2 example, one of the templates 61 could represent one line of the mufti-line table, with the 3 appropriate PC tags 57 and FC tags 59 directing the inserted table content for each invocation of the 4 line template 61. - --- .. __ . ..~ _ . . '. .,. .. -_ -[00107] Using this file organization model, it is possible to determine the physical path to an ML
6 PT61 file given the application root path, the file format, the language, and the file name including 7 any application specific levels.
8 [00108] For example, an application may have one application specific level defined that has the 9 following divisions: common, orderEntry and orderHistory. The application itself has a series of pages 49 that have to do with entering and processing an order and another set of pages 49 that have 11 to do with selecting and viewing order history. The set of ML presentation template files 61 may be 12 organized in the following way:
13 .../orderApplication/html/en CA/common/header.html 14 .../orderApplica-tion/html/en~ CA/common/footer . html .../orderApplicati_on/html/en CA/orderEntry/search.html 16 .../orderApplication/html/en CA/orderEntry/entry.html 17 .../orderApplication/html/en_ CA/orderEntry/submit.html 18 .../orderApplication/html/en CA/orderHistory/search.html .

19 .../orderApplication/html/en_ CA/orderHistory/display.html with other sets of files under:

21 .../orderApplication/html/fr_ CA/...

22 .../orderApplication/hdml/en- CA/...

23 .../orderApplication/hdml/fr CA/...

[00109] The individual ML presentation template files 6lcan be designed using an appropriate 26 WYSIWYG editor such as HomeSite for HTML ales as developed by Macromedia of San 27 Francisco, CA. Any other suitable editor known to those skilled in the art rnay be employed. The 28 ML presentation template flea 61 themselves contain "pure" markup language (e.g. HTML).
29 [00110] The ML PT files 61 represent pages that can contain d~n~amic content; e.g. ML PT 67.
Any dynamic content must be placed inside conic°ols 63 located on the page. Each markup language _27_ 1 has its own set of controls. Each control 63 has an identifier (i.e. in HTML, id="idValue") keyword 2 defined in order for the dynamic content to be inserted into the control 63.
In the ML file, the 3 control may have dummy data. This dummy data is useful for display purposes during the design 4 phase of the ML file. However, this dummy data is removed automatically when the dynamic data is inserted into the control. In the case of an HTML based ML presentation template dynamic file 67, 6 any of the following controls will be considered for dynamic data insertion so long as each control 7 has a unique value for the identifier keyword (i.e., i d= "i dVa 1 a a °'): Text field, Password field, 8 Hidden field, Text area, Table, List box, Check box, Radio button, Image, Push button, Image 9 button, Submit button, Reset button, Link and Span. In alternate embodiments, the ML file may be composed in any other markup language known to those skilled in the art, such as HDML or WML.
11 PRESENTATION COMPONENT (PC)e 12 [00111] Referring to Figure 4, the presentation component (PC) 161 is illustrated 13 schematically. The PC 161 is a distinct, independent piece of presentation functionality. Each 14 presentation component 161 processes the corresponding presentation element. In a preferred embodiment, every presentation component 161 exits as a Java class that is based in a generic base 16 class. When a client application requires a presentation component 161, it is simply instantiated 17 using Java reflection based on the logical name of the presentation component 161. The presentation 18 component 161 conforms to the specification of a Java Bean.
19 PRESENTATION COMPONENT (PC) TAG E~TENSIONSo [00112] The presentation component files 161 are involved using a set of presentation component 21 tag extensions 57. The presentation component file custom tag extensions 57 provide the linkage 22 between the controls 63 in the presentation files 67, the dynamic data 27 and the presentation 23 component 161 in the JSP page ~.9. h~ addition , these extensions 57 also provide the ability to 24 generate a subsequent display page 79.
The~x~~~ratw~i:~.on,:p~,g~7C~~
- 28 _ 1 [00113] This tag defines that a specific presentation component file 161 is.
to be used in .the 2 current processing page 49. This tag has the following format: l 3 <presentation:page name="presentation Name" root=" rootPath"
4 source="fileName" value="fileName"
format="presentationFormat" language="languageSpecification"
6 absolute="true" />
7 Where:
8 presen to ti onName is the unique name that this presentation page will be referenced by 9 within this processing page 49 roo tPa th (optional) is the root path of the file .11 fi 1 eName is the file name including any application specific level name 12 pres en to ti onForma t is the format of the presentation file 61, which must be one of the 13 following values: html, hdml or wml.
14 1 anguageSpeci fi ca ti on (optional) is the language of the content of the presentation file 61, which if specified, must be one of the following values: en_CA, f r CA and so on.
16 In a preferred embodiment, the name and format attributes are mandatory.
Exactly orie of 17 the source or value attributes must be specified. Each of the attributes except value 18 can be directly specified as a value or else can be a reference (i.e.
dataReference) to 19 dynamic data. The path to the presentation file is considered to be relative unless the absolute attribute is specified as true.

22 The~reser~tation:control Tai 23 [00114] This tag liy~l~s a control 63 from a dynamic presentation template file 67 to the source of 24 the control's dynamic data and the presentation component 161. This tag is used when the type of control 63 is supported for the particular format of the dynamic presentation template file 67. In a 26 preferred embodiment, this tag has the following format:
27 <presentation: control name='° controlName" type=" controlT~rpe"
28 parentPresentation="parentName'°
29 value="IiteralValue" source=" dataReference"
optSource="dataReference" empty="boolea_.r~Value"
31 id="identifier" conditionalE~ecution="true°' />
_2~_ 1 Where:
2 Con trolName is the unique name that this control will be referenced by 3 Con trot Type is the specific type of the control. If HTML is the selected ML, then the 4 HTML controls include input (requires attribute type set to text for text field, set to pas sword for password 6 field, set to hidden for hidden field, set to button for push button, set to image for 7 image button, set to submit for submit button, set to reset for reset button, set to 8 checkbox for checkbox, set to radio for radio button), textarea, table, select 9 (list box), img (image), a (link) or span.
paren tName is the name of the parent containing this control which is either a presentation 11 page or another control.
12 If a control is specified that is immediately contained in a page, then the value is the 13 presentation name, a dot ('.') and the control name. If a control is specified that is within 14 , another control that is immediately contained in a page,~then the value is the presentation name, a dot ('.'), the immediate control name, a dot ('.') and the control name. There is no 16 limit to the embedding of controls within controls.
17 Ii teralValue is a hard-coded literal value 18 da taReference is a reference to dynamic data 19 The type of data referenced by this attribute must be compatible with the control type.
The dynamic data reference can be either a reference to keyword-value paired data defined 21 for this processing page or servlet request or else a reference to returned result data, from an 22 application component.
23 If the value of a keyword-value paired data is a simple value, then the reference is simply the 24 keyword itself.
e.g. orderNumber 26 If the value of a keyword-value paired data is a structure, then the reference is the keyword, a 27 ~ dot ('.') and the element name of the structur e. (If the element is itself a structure, then it can 28 also be further qualified.) 29 e.g. orderHeaderAttr . orderStatus A returned result data reference includes the function component 59 instance name, a dot 31 ('.') and the name of the returned result data element.
32 e.g. OrderGet_OrderEntry. orderTD
33 If the returned result data element is a structure and the desired dynamic data 27 is an 34 element of the structure, then the returned result data element is qualified by a dot ('.') and the element name. (If the element is itself a structure, then it can also be fuxther qualified.) 36 e.g. OrderGet'OrderEntry.orderHeaderAttr.orderStatus 37 If the dynamic data reference begins with the character "@" then it is an implicit indirect 38 reference. Iia this case once the returned result data element has been detez-mined, then it is 39 itself considered to be a dynamic data referezlce that is then re-evaluated by applying the rules stated above. (If the returned result data element that is subsequently considered to be a 1 dynamic data reference also begins with the character "@" then it is also an implicit indirect 2 ~ reference and the evaluation process begins all over again.) 3 booleanValue is either true or false 4 i den ti fi er (optional) is the identifier of the control in the presentation file The control in the dynamic presentation file 67 must have an equivalent 6 id="identifier" attribute. If the identifier is not specified in the 7 presentation: control tag, then an attribute with name id must be set to the value 8 identifierin apresentation: attribute tag.
9 conditionalExecution="true" this attribute indicates that the execution of this tag is conditional upon the enclosing applicationcomponent : if tag 11 currently having a true value 12 The name, type andparentPresentationattributesaremandatory.Onlyoneofthe 13 value, source or optSource or empty attributes maybe specified. If optSource 14 is specified, then the da taRef eren ce can be a non-existent data reference. The specified attribute provides the body content for the control in the ML file. If none of these attributes 16 are specified then no body content is replaced in the ML file.
1~
18 The presentation: attribute Tag 19 [00115] This tag specifies a specific attribute for a specific control 63.
This tag must be defined within the body of a presentation: control tag. This tag has the following format:
21 <presentation:attribute name="attributeName"
22 value="literal Value°' source="dataReference"
23 optSource="da taReference'°
24 empty="booleanValue" />
Where:
26 a t tribu teName is the name of the attribute to set 27 li teralValue is a hard-coded literal value 28 dataReference is a reference to dynamic data 29 booleanValue is either true or false All of the attributes are mandatory except that only one of value or source or 31 optSource or empty may be specified. If optSource is specified, then the 32 da taReference can be a non-existent data reference.

34 Thex~~atiox~:produGeP~a,~e'fa~

1 [00116] This tag defines that output for a display page is to be produced based on the specified 2 presentation template file 61 after first populating all dynamic content into the PT. The output is 3 generated at the time that the tag is encountered in the processing file 49;
i.e., during execution of 4 the muli-tier application. If there are multiple producePage tags encountered, then the generated display page 79 will contain the concatenation of the output from each of the produc ePage tags in 6 the order that they were encountered within the processing file 49. This tag has the following 7 format:
8 <presentation:producePage page="PresentationPageName"
9 conditionalExecution="true" />
Where:
11 Presen to ti onPageName is the name of the presentation file 61 to produce output for 12 The presentation file 61 must have been previously defined by a presentation : page 13 tag.
14 conditionalExecution="true"this attribute indicates that the executionofthistag is conditional upon the enclosing app 1 i c at i on component : i f tag currently having a 16 true value 17 The page attribute is mandatory.

The, presentation: clear Tai 21 [00117) This tag clears the JSP 49 output buffer. It is typically used to clear out the empty lines 22 that the JSP server puts in around the XML tags before any content is generated. In HTML, this data 23 is ignored, but plain text documents should not have these extra lines. The tag has no attributes.
24 The presentation : interceptor Tai [00118] This tag is a body tag that intercepts the output of its body and inserts it into the 26 resul tValue page variable and optionally copies it to the page output.
This tag has the following 2~ format:
28 <presentation:interceptor inter_ceptEnab7_ed="booleanTTaIue"
29 dvplicate0utput="booleanValue" />

1 Where:
2 interceptEnabled is an expression that, if true, enables the interceptor 3 duel i ca t e0u tpu t is an expression that, if true, copies the intercepted output to the 4 enclosing page The interceptEnabled attribute is mandatory; the duplicateoutput attribute is 6 optional.

8 Defining The Processing Logic For a Servlet Client Application Using Processing Files 9 [00119] Referring to Figures 4, 6(a), 6(b), 7, 8(a), 8(b) and 9, the processing logic of a JSP 49 in a servlet client application is illustrated schematically according to a preferred embodiment of the 11 present invention. The processing logic for a servlet client is defined in a set, of JSP 49 processing 12 files. A processing file performs two distinct processing roles.
13 [00120] First of all, a processing file 49 provides the ability to invoke function components 59 14 that implement specific processing functionality. The specific processing functionality includes processing input data 33 and providing output data 27.
16 [00121] The processing f le 49 also defi'_nes the links 69 between the controls 63 that are defined 17 within the dynamic pr esentation template files 67 azid the dynamic data itself. After all the specific 18 processing functionality has been completed for a specific output page 79 and all of the dynamic 19 data 27 has been generated, the next display page 79 can be produced by populating the dynamic data into the dynamic presentation files 67 and generating the presentation element with the 21 presentation component 161.
22 , [00122] In a preferred embodiment, a processing file 49 is implemented using JavaServer Pages 23 (JSP). In order to malce the processing files user-friendlier, two sets of custom JSP tag extensions 24 have been introduced. The function component (FC) custom tags 55 provide the ability to invoke function components 59. The presentation file custom tags 61 provide the linkage between dynamic 26 data and the conta~ols 63 in the presentation hl.es and also provide the ability to generate the display 27 page 79 with the presentation component 161.
.. 33 ._ 1 [00123] A client application infrastructure 97 defines the classes which implement the custom JSP
2 FC tag extension 55 and PC tag extension 57 libraries that together make up the functional 3 framework of the client application 71. The classes support the client application's function 4 components 59 presentation components 161.
The infrastructure 97 provides the interface between function components 59 and the specific 6 application clients. It also provides suitable connection points for servlet GUIs, applet GUIs and 7 direct programmable interfaces. The infrastructure further provides a set of classes, which 8 implement the custom JSP extension libraries responsible for supporting the client application's 9 presentation components 161.
[00124] Referring to Figures 10 and 11, a logical view of a client application 71 assembled in 11 accordance with a preferred embodiment of the present invention is illustrated. For illustrative 12 purposes a servlet client application is described. The servlet engine 23 is invoked by the user 13 entering the URL of the starting JSP 49 of the application 71 from within a browser on terminal 11.
14 [00125] The servlet client 71 logically consists of a series of java server pages 49, with eachpage defining a portion of the processing logic the client application 71. Each page 49 has one or more 16 associated presentation templates 61 providing the "look and feel" of the page. Each page 49 also 17 has one or more associated function components 59 providing its processing logic and presentation 18 components 161 providing its presentation logic.
19 [00126] At any specific point in the execution of the client application 71, the user operating terminal 11 is viewing a page in a local browser window and interacting with it. The user enters 21 information and then causes (e.g. by "pushing" a button) data from the page to be returned to the 22 web server 15 along with a pointer to the next page 49 of the client application 71. The user's data is 23 returned to the web server 15 in the form of a set of keyword-value pairs 73.
24 [00127] At this point, the next page a.9 of the client application 71 is processed, the output data 27 of rxjhich is generated by the PC 161 and used in the gencr ation of a new viewing page 1 79, which is sent back to the user's browser window on terminal 11 and the whole cycle begins 2 again.

4 [00128] In summary, each page 49'of a servlet client application 71:
~ receives as input, a set of keyword-value paired data 73 6 ~ performs a processing step 77 7 ~ Generates a new display page 79 for the user operating terminal 11 containing all of the 8 required embedded programming constructs to both redirect control flow to a subsequent 9 page 49 and to return keyword-value paired data 73 to that subsequent page.
(00129] In alternate embodiments, an applet client 93 or a direct programmable interface 11 client 95 may be assembled. (Figure 13) 12 [00130] The applet client 93 is a Java Swing-based interface to client applications 71 running on 13 terminal 11. The user on terminal 11 interacts directly with the application as it is running locally.
14 The client application 71 communicates across the communications network 13 (e.g., the Internet) with the Net* Suite server s via a C~RBA interface 97. Responses are written directly to the screen 16 using Java Swing GIJI components.
17 [00131] The direct programmable interface is another mechanism that uses the applications. A
18 direct programmable interface client 95 is a specific set of Java code. The direct client 95 19 instantiates a set of function components 59 to provide the processing logic for the client application 71. The direct client 95 sets prerequisite data 33, involves the execute() methods and gets returned 21 data 27 for each function component 59 instance as appropriate.
22 [00132] A client using the direct programmable interface provides its own GUI if one is required.
23 The function component 59 linkages are "hard coded" within the client logic itself to def ne the 24 application.
L~lluse~atdve example:

1 [00133] Referring to Figure 12, the use of FC taglib directives 51, FC-tags SS FCs S9, PC taglib 2 directives S3, PC tags S7 and PCs 161 to generate an output page 79 is illustrated by way of example 3 according to a preferred embodiment of the present invention. In the present example, there is an 4 order entry application that includes an administrative step to approve orders. In this case, an order is submitted after the order is approved.
6 [00134] For this example, it is assumed that the previous JSP 49 selected the order and an order 7 identifier (orderlD) FC S9 is available as a returned result from an OrderSelect FC S9 8 executed on the previous JSP 49.
9 (00135] The current JSP 49 is the OrderSubmit page. The processing logic for this page involves calling a FC S9 (OrderGet) that will retrieve the order details 83 for the selected order.
11 In this case, the resulting output page 79 to be returned to the user's browser window will display the 12 order number 81 and the order details 83. If the order details 83 are not available, then the FC S9 13 returns a FC EXCEPTION 1 exception. In this case the application will jump to an error JSP
14 (noOrderError . j sp). Any other exceptions are handled by forwarding to a general error JSP
page (er ror . j sp).
16 [00136] The PTs 61 that define the layout for output page 79 utilize a PT
header 8S
17 (OrderApplicationHeader.html) and PT footer 87 1~ (OrderAppl i cat ionFooter . html) (in HTML format) that is common across all pages in this 19 application. There is no dynamic data inserted within the PT header 8S or PT footer 87, they are examples of static presentation templates 6S.
21 [00137] The PT main body 89 of the current page is from the OrderSubmi t HTML file. This 22 file contains a text field (read only) that will display the order nuynber 81. This control is labeled 23 with id=OrderNumFiel.d. The order details 83 will be displayed in table format using a table 24 control. The t~ c~le control is labeled with id=OrderDetai 1 s. Finally, there is a submit bunion 91 _3u_ 1 on the page which will invoke a subsequent JSP page (submit . j sp) which will actually submit 2 the order. The PT main body 89 is an example of the dynamic PT 67.
3 [00138] The PT HTML files 85.,. 87_and_:89~rovide xhe layout template for the display page 79 4 generated from the JSP 49, which is generated by the PC 161.
(00139] The JSP 49 for this part of the application is as follows.
6 2 <!-_*************************************************************

3 This page is used by an administrator to submit an order.

8 4 *****************************************************************_->

1~ 6 <%@ page session="true" buffer="64kb' autoFlush="true"

11 7 isThreadSafe="true' errorPage=".../errorPage.jsp" %>

12 <%@ taglib uri="/servlet/FunctionComponentTagsClient.jar"

13 prefix="application component"
%>

14 8 <o@ taglib uri='/servlet/PresentationComponentTagsClient.jar"

prefix="presentation"
%>

16 9 <functionComponent:init >

17 10 

11 <functionComponent:call name='OrderGet OrderEntry" >

21 12 <functionComponent:prerequisite target='ordered"

22 13 source='OrderSelect_OrderEntry.orderID" />

~3 14 <functionComponent:errorname="NoOrder'page="no0rderError.jsp"
/>

24 15 </functionComponent:call>

16 

17 <presentation:page name="header" source="OrderApplicationHeader"

~$ 18 language="en CA" format='html' />

20 

33 21 <presentation:page name="body" source="OrderSubmit"

34 22 language="en CA" format="html' />

23 <presentation:controlname='OrderNumField'type="span"id="Ord~erNumFiel 36 d"

37 24 parentPresentation=''body"sour_ce="OrderGet OrderEntry.orderNum"

38 ~>

1 25 <presentation:coritrol name="OrderDetails" type="table"
2 id="OrderDetails"
3 2s 4 parentPresentation="body'°source="OrderGet OrderEntry.orderDetailTable"
/>
6 2~
7 28 
9 29 <presentation:page name="footer" source="OrderApplicationFooter"
30 language="en CA" format="html" />

12 32 
14 34 <presentation:producePage page=°'header" />
35 <presentation:producePage page="body" />
16 36 <presentation:producePage page='°footer" />
17 [00140] Igeferring to Figure 13, an expanded schematic view of the system 10 and the processed 18 outputs of the client application 71 are illustrated according to a preferred embodiment of the present 19 invention. A network user operating the network terminal 11 requests the remotely located resource (JSP 4~9) via the network 13.
21 [00141] The JSP 4~9 includes FC tag library directives 51, which specify the custom FC tags 55 22 that rnay be used by the senvlet engine 23 when processing the user's request, and PC tag library 23 directives 53, which specify the custom PC tags 57 that rnay be used by the servlet engine 23 when 24 assem'aling the output page 79 that is returned to the user at tey-minal I
1. The JSP 49 further includes FC tags 55 that are used to invoke their corresponding FCs 59 and PC tags 57 that provide links to 26 the PCs 161.
2~ [00142] The FC tag 55 may be used to call its corresponding FC 59. It does this by specifying the 28 FC 59 to be involved (by "mane"). A further FC tag 55 defines the prerequisite or input data 33 and 29 provides a reference 1 O 1 to the "source" of the input data 33. In the present example, the input data 33 is located in the database 17, which is accessed by the application server 19 via database server 31 119. 'Thus when the FC 59 is executed, it requests and receives the input data 33 from the database _3g_ 1 17 via the application server 19. The data is then processed by the FC 59 and the data output 27 is 2 generated.
3 [00143] The PC tag may be used to call its corresponding PC 161. It does this by specifying the 4 PC 161 to b~ involved (by-'-'name"). A reference is also provided to the "source" of the PT 61.
Thus, when the PC 161 is executed, it processes the presentation instructions in the presentation 6 template 61 and generates a corresponding presentation element or output 79.
7 [00144] The PC tags 57 may refer to one of two types of PTs 61; static PCs 65 and dynamic PTs 8 67. The PTs 65 and 67 are referred to by name and location or source. The static PTs 65 are ML
9 files that include ML statements that define presentation elements of a portion of the output page 79.
The static PTs 65 neither include references to nor do they incorporate the output data 27 that is 11 generated by the FC 59 during processing by the PC 161. They are generally reserved to defining 12 those elements of the output page 79 that are common to all output pages 79 of the client application 13 ~79, such as the header or footer, although their use is not limited to this role.
14 [00145] The dynamic PTs 67 are also ML files that include ML statements that define the presentation elements of a portion of the output page 79. However, they also include at least one 16 control 63, which provides the reference or link 69 to the output data 27 that is generated by the FC
17 59. The PC tags 57 that refer to the dynamic PTs 67 include, in addition to the name and "source"
18 of the dynamic PT 67, a reference to the type of control 63 to be included in the portion of the output 19 page 79 and a reference or direction 103 to the "output data 27" that is to be incorporated in the control 63 during processing by PC 161.
21 [00146] Once the servlet engine 23 has executed the compiled java servlet 31 and processed the 22 user's request, it generates the output page 79, the portions of which being defined by the PTs 6S and 23 67. It should be recognised that the JSP 49 includes a number of Pts 61, each responsible for 24 defining a portion of the output page 79. These PTs 6I can be reusable, such that the same PTs 65, 67 can be lxnl~ed to differ ently configured PC tags 57. For exsznple, the PT
6 T can be coupled by 26 two diffez~ent controls havi~.zg reference 69 to two diff~~~ent output data 27. Therefore, this would 1 result in two tables inthe output page 79 having two dissimilar body contents dictated in part by the 2 differing contents of the two output data 27.
3 CLIENT APPLICATION INFRASTRUCTURE:
4 [00147] Refernng to Figure 14, the overall architecture of a client application assembled using a series of function components 59 is illustrated. For illustrative purposes, the servlet client 75, the 6 applet client 93 and the direct programmable interface client 95 are all depicted interacting with the 7 FCs 59 via an alternate embodiment of the client application infrastructure 97. The servers 19 8 implement, for example, the CORBA or EJB interface 99 for the client application 71 to use.
9 Specific server 19 calls are made from within a FC 59 during execution of the client application 71 processing logic.
11 [00148] The client application infrastructure 97 defines the classes which implement the custom 12 JSP FC tag extension 55 and PC tag extension 57 libraries that together make up the functional 13 framework of the client application 71. In a preferred embodiment, one set of classes implements 14 the custom JSP extension libraries responsible for supporting the client application's function components 59 (the function component infrastructure), and a second set of classes implements the 16 custom JSP extension libraries responsible for supporting the client application's presentation 17 components 161 (the presentation component infrastructure).
18 FUNCTION COIVIPONEhTT INFRASTRUCTURE (FCI~:
19 [00149] The FC 59 infrastnicture provides the interface between function components 59 and the specific application clients: servlet client 75, applet client 93, DPI client 9.5. It provides suitable 21 connection points for servlet GUIs, applet GUIs and direct programmable interfaces. The FC
22 Infrastructure provides a set of classes, which implement the custom JSP
extension libraries 23 responsible for supporting the client appli.cation.'s fln2CtlOn comp~nexTts 59. These classes include 24 the ~'zcaa~fi~~z ~orzz~~zzezzi ,~axl ~~'~e",~' ~'tz.za~~i;a.on~~.rrfa,~acaaz~a~r~.~.~~at'.~~g~~~a:~°~.T'.za:~ca, .~'vxa ~ ~ a ~.z~ Gc~,~~cax~ ~.~ tr ~'~ .~ .~ 2''~~, F'u~ ~ t;. ~ ~,z~
~~~~~a;~oxa. ~,~ ~: ~ ~ ~ 1 °~~ ~.~a ~ ~: x~ ~'.zWc~
_40_ 1 FunctionComponentPrerequisiteTag, FunctionComponentDebugTag, 2 FunctionComponentErrorTag, FunctionComponentGetValueTag, and the 3 FunctionComponentGetValueTagExtralnfo.
4 Public Class Function Component InitTag [00150] This class implements the custom JSP tag extension library for initializing the function 6 component custom tags SS. This tag exists to define variables in the 7 FunctionComponentInitTagExtraInfo class.
8 Public Method doStartTag ( ) 9 [00151] Since there is no support for content within this tag, this method simply returns SKIP BODY.
11 Public Method doEndTag ( ) 12 [00152] There is no specific processing required. The value EVAL PAGE is returned.
13 Public Class FunctionCompone.ntlnitTagExtralnfo 14 [00153] This class creates all of the scripting variables for the function component tags SS.
Public Class FunctionComponentCallTag 16 [00154] This class implements the custom JSP tag extension library for function component S9 17 calling support.
18 Public get/set Methods 19 [00155] In a preferred embodiment, every attribute of the tag S S must have an associated get and set method. I~ particular, the follorJing ~~ethods are created.

1 .getName ( ) , setName ( ) 2 .getDontResetAllData(),setDontResetAllData() 3 .getDebugLevel ( ) , setDebugLevel ( ) ~ Private Method setFunctionComponentInstance ( ) 6 [00156] This method saves the current function component 59 instance. The function component 7 59 instance is set by the functionComponent : call tag since it will be retrieved by the 8 functionComponent : prerequisite tag and the functionComponent : error tag.
9 Protected Method getFunctionComponentlnstance ( ) [00157] This method saves the current function component 59 instance.
11 Protected Method setFunctionComponent~xception ( ) 12 [00158] This method saves a function component exception name and page that was specified by 13 a functionComponent : error tag. The set of exceptions are stored in a hashTable where 14 the key is the exception name and the value is the exception page.
Private Method getFu~actionComponent~xception ( ) 16 [00159] This method returns the exception page for the named exception or null if no page was 17 specified.
18 Public Method doSta~: tTag ( ) 19 [00160] The function component 59 name is parsed and separated into the class name and the function component instance description. The function component 59 is then instantiated and the 21 instance description. is set. The function component instance name and obj ect reference are saved in 22 a hash table thsf. is part of the session context. In addition, the function component instance itself is 23 saved using the setFunctionComponentlnstance ( ) method.
_. 42 _ 1 (00161] Prerequisite data 33 and exception handling is set within the body of this tag. Actual 2 invocation of the function component 59 is done by the doEndTag ( ) method after the body has 3 been processed.
4 [00162] This tag requires a body therefore this method simply returns EvAL
BODY TAG.
Public Method doAf terBody ( ) 6 [00163] If there is any body content, then it should be appended to the buffered output for the 7 page.
8 [00164] No iteration over the body is required; therefore this method simply returns 9 SKIP BODY.
Public Method doEndTag ( ) 11 [00165] Any buffered output for the page should be written.
12 [00166] All of the prerequisite data 33 must have been set by 13 functionComponent : prerequisite tags in the body.
14 [00167] The execute ( ) method of the function component 59 is invoked.
[00168] If an exception is thrown, then it must be interpreted in the following manner. If there 16 was an error descriptor attribute set for the exception, then the exception should be saved in the 17 funct ionComponentExcept ion script variable and the request forwarded to the defined JSP
18 49. In this case the vah~e SKIP PAGlC is returned. In all other cases, including when no exception 19 was thrown, the value EVAL-PAGE is returned.
Public Class Z't~.r~c~a.caxz~'c~..~ztpox~e.~at~~a.lZ~'a.~r-,E~~.ra~aa~'o _43_ 1 [00169] This class implements the scripting variable definition for the 2 functionComponentException that is set in the case that an exception (defined by the 3 functionComponent : error tag) is handled for the functionComponent : call tag.
4 Public Class FunctionComponentPrerequisiteTag [00170] This class implements the custom JSP tag 55 extension library for function component 59 6 prerequisite data 33 setting support.
7 Public get/set Methods 8 [00171] Every attribute of the tag has an associated get and set method. In particular, the 9 following methods are created.
.getTarget ( ) , setTarget ( ) 11 .getSource ( ) , setSource ( ) 12 [00172] The type of each of this attribute is String rather than the actual type of the prerequisite 13 data 33.
14 .getValue ( ) , setValue ( ) .getEmpty ( ) , setEmpty ( ) 17 Public Meth~d d~Sta:~tTag ( ) 18 [00173] If this tag is not within a functionComponent : call tag, than an appropriate 19 JspTagExcept ion is thrown. The function component 59 object itself can be retrieved using the getFunctionComponentInstance ( ) method of the functionComponent : call tag 21 handler. Since there is no support for content within this tag, this method simply returns 22 SKIP BODY.
23 Public I~ctl.ROd dol~n~'f~.g ( ) _ L~l~ _ 1 [00174] Setting the target data element is done using reflection on the function component 59 2 class.
3 [00175] If the empty attribute~is set then an empty value is used for the set method. If the 4 value attribute is set then it provides the literal value to use for the set method. Otherwise the source attribute must be interpreted to get the value to use for the set method.
6 [00176] The interpretation of the source attribute involves the following steps.
Separate the base name (everything to the left of the first "." if there is one) from the 8 qualification path (everything to the right of the first "." if there is one) 9 If the base name is a script variable name Then lookup the script variable name value 11 Else if the base name is a servlet request parameter name 12 Then lookup the servlet request parameter name value 13 Else the base name must be a function component 59 instance name 14 Lookup the function component 59 instance name to get the function component 59 instance object 16 If there is a qualification path 17 Then evaluate the qualification path by calling get methods on each of the elements 18 of the qualification path 19 Now there should be a value for the prerequisite data element The value EVAL PAGE is retuaned.

22 Public Class Frx~ct3~a.2x~oanpo.~a.ezat.i7ebxag~'''ag 23 [00177] This class implements the custom JSP tag extension library for function component 24 debug support.
Public get/set Methods 26 [00178] In a preferred embodiment, every attribute of the tag has an associated get and. set 27 method. In particular, the following methods are created.
28 .getDebugL~evel ( ) , setDebugLevel ( ) 29 .getDehugFi7_e ( ) , setDebugFile ( ) 1 .getValue ( ) , setValue ( ) 2 .get Source ( ) , setSource ( ) 4 Public Method doStartTag ( ) [00179] Since there is no support for content within this tag, this method simply returns 6 SKIP BODY.
7 Public Method doEndTag ( ) 8 [00180] Setting the target data element is done using reflection on the function component class.
9 [00181] If the empty attribute is set then an empty value is used for the set method. If the value attribute is set then it provides the literal value to use for the set method. Otherwise the 11 source attribute must be interpreted to get the value to use for the set method.
12 [00182] The interpretation of the source attribute involves the following steps.
13 ~ Separate the base name (everything to the left ofthe first "." if there is one) from the 14 qualification path (everything to the right of the first "." if there is one) ~ If the base name is a script variable name 16 ~ Then lookup the script variable name value 17 ~ Else if the base name is a sezvlet request parameter name 18 ~ Then lookup the servlet request parameter name value 19 ~ Else the base name must be a function component 59 instance name ~ Lookup the function component 59 instance name to get the function component 21 instance object 22 ~ If there is a qualification path 23 ~ Then evaluate the qualification path by calling get methods on each of the elements 24 of the qualification path ~ Now there should be a value for the prerequisite data element 26 ~ The value EVAL _PAGE is returned.

28 Public Cl~.ss ~%'u,nat;~.aaaCa.~~.a.~~e~t~~°~a _4~_ 1 [00183] This class implements the custom JSP tag extension library for function component 59 2 error support.
3 Public get/set Methods 4 [00184] Every attribute of the tag must have an associated get and set method. In particular, the following methods are created.
6 .getName ( ) , setName ( ) .getPage ( ) , setPage ( ) 9 Public Method doStartTag ( ) (00185] If this tag is not within a functionComponent : call tag, than an appropriate 11 JspTagExcept ion is thrown. The function component 59 object itself can be retrieved using the 12 getFunctionComponentInstance ( ) method ofthe functionComponent : call tag 13 handler. Since there is no support for content within this tag, this method simply returns 14 SKIP ~30DY.
Public Method doEx~.dTag ( ) 16 [00186] Defining the error is done by calling the setFunctionComponentException ( ) 17 method of the functionComponent : call tag handler.
18 [00187] The value EVAL PAGE is returned.
19 Public Class FunctioxaComponeratGetValueTag [00188] This class implements the custom JSP tag extension library for getting function 21 component 59 returned result data vah.~es.
22 Public get/sct I~lethods -42~

1 [00189] In a preferred embodiment, every attribute of 'the t~.g has an associated get and set 2 method. In particular, the following methods are created.
3 .getSource ( ) , setSource ( ) 4 Public Method doStartTag ( ) [00190] Since there is no support for content within this tag, this method simply returns 6 SKIP BODY.
7 Public Meth~d doEs~dTag ( ) 8 [00191] Setting the target data element is done using reflection on the function component class.
9 [0019] If the empty attribute is set then an empty value is used for the set method. If the value attribute is set then it provides the literal value to use for the set method. Otherwise the 11 source attribute is interpreted to get the value to use for the set method.
12 The interpretation of the source attribute involves the following steps.
13 Separate the base name (everything to the left of the first "." if there is one) from the 14 qualification path (everything to the right of the first "." if there is one) If the base name is a script variable name 16 Then lookup the script variable name value 17 ~ Else if the base name is a servlet request parameter name 18 Then lookup the servlet request parameter name value 19 Else the base name must be a function component 59 instance name Lookup the function component 59 instance name to get the function component 59 21 instance object 22 If there is a qualification path 23 Then evaluate the qualification path by calling get methods on each of the elements 24 of the qualification path Now there should be a value for the prereqa.~isite data element 26 ~~ 'fhe value EVATd P.AG~ is returned.
_.

2~

28 Public Class .~u~oL.aors~o~xe~a~Ge~'~'a~raeTar~.~'.~tx~x.~.~'o _48_ 1 [00193] This class implements the scripting variable definition for the re sul tValue that is set 2 for the functionComponent : getValue tag.
3 PRESENTATION COMPONENT INFRASTRUCTURE (PCI~:
4 [00194] The PC 161 Infrastructure provides a set of classes, which implement the custom JSP
extension libraries responsible for supporting the client application's presentation components 161.
6 These classes include the PresentationPageTag, PresentationControlTag, 7 PresentationAttributeTag, andthe PresentationProducePageTag.

9 Public Class PresentationPageTag [00195] This class implements the custom JSP tag extension library for presentation component 11 161 support.
12 Public get/~et Meth~ds 13 (00196] Every attribute of the PC tag 57 must has an associated get and set method. In particular, 14 the following methods axe cheated.
.getName ( ) , setName ( ) 16 .getRoot ( ) , setRoot ( ) 1~ .getSource ( ) , setSource ( ) 18 .getFormat ( ) , setFormat ( ) 19 .getLanguage ( ) , setLanguage ( ) 21 Public ll~Ietho~l doStaxt'~ag ( ) 22 [00197] Since there is no support for content within this tag, this method simply returns 23 S Na: ~ ~o~~.
24 Public et:hod dca~~~x~.'~ac~ ( ) 1 [00198] A page producer object is-instantiated; named the value of the name attribute and stored 2 in the pageContext. The associated ML file is determined using the value of the source, 3 format and language attributes. ---4 [00199] After all processing is complete, the value EVAL PAGE is returned.
Public Class PresentationControlTag 6 [00200] This set of classes implement the custom JSP tag extension library for presentation 7 component 161 support of a specific control.
8 Public get/set Methods 9 [00201] Every attribute of the tag has an associated get and set method. In particular, the following methods are created.
11 .getName ( ) , setName ( ) 12 .getType ( ) , setType ( ) 13 .getTd ( ) , setTd ( ) 14 .getParentFresentation(),setParentPresentation() .getSource ( ) , setsource ( ) 16 .getValue ( ) , setValue ( ) 17 .getEmpty ( ) , setEmpty ( ) 19 Public Method ctoSta~etTag ( ) [00202] This tag 57 requires a body therefore this method simply returns EVAL
BODY TAG.
21 Public Method doAf terBody ( ) 22 [00203] Lf there is any body content, then it should be appended to the buffered output for the 23 page. No iteration over the body is required; therefor°e this method simply r eturns ~I~T P~BOD Y.
24 Public lflethod dr~l~r~d~'ac~ ( ) 1 [00204] This parent name is a known page producer object or control object that is found within 2 the pageContext.
3 [00205] A control of the appropriate type is instantiated and stored in the pageContext.
4 [00206] The control's data control property is set. If the empty attribute is set then an empty value is used for the property. If the value attribute is set then it provides the literal value for the 6 ~ property. Otherwise, the source attribute is interpreted to get the value for the property. The 7 interpretation of the source attribute involves the following steps.
8 Separate the base name (everything to the left of the first "." if there is one) from the 9 qualification path (everything to the right of the first "." if there is one) If the base name is a script variable name 11 Then lookup the script variable name value 12 Else if the base name is a servlet request parameter name 13 Then lookup the servlet request parameter name value 14 Else the base name must be a function component 59 instance name Lookup the function component 59 instance name to get the function component 59 16 instance object 17 m If there is a qualification path 18 ~ Then evaluate the qualification path by calling get methods on each of the elements 19 of the qualification path ~ Now there should be a value for the prerequisite data element 21 After all processing is complete, the value EVAL'PAGE
is returned.

23 Public Class Pre~en~atior,~l~~.~~.ba~~eTag 24 [00207] This set of classes implement the custom JSP tag extension library for presentation component 161 support of attributes of a specific control.
26 Public get/set l~cth0ds 27 (0020] Every attribute of the tag h.as an associated get and set method. In particular, the 28 following methods axe created.

1 .getName ( ) , setName ( ) 2 .getSource ( ) , setsource ( ) 3 .getValue ( ) , setValue ( ) 4 .getEmpty y) , setEmpty ( ) 6 Public Method doStartTag ( ) 7 [00209] Since there is no support for content within this tag, this method simply returns 8 SKIP BODY.
9 Public Method doEndTag ( ) [00210] The parent control is found within the pageContext and the attribute is set.
11 [00211] If the empty attribute is set then an empty value is used for the property. If the value 12 attribute is set then it provides the literal value for the property.
Otherwise the source attribute is 13 interpreted to get the value for the property. The interpretation of the source attribute involves the 14 following steps.
~ Separate the base name (everything to the left of the first "." if there is one) from the 16 qualification path. (everything to the right of the first "." if there is one) 17 ~ If the base name is a script variable name 18 ~ Then lookup the script variable name vs.lue 19 ~ Else if the base name is a semlet request parameter name ~ Then lookup the servlet request parameter name value 21 ~ Else the base name anust be a function component 59 instance name 22 ~ Lookup the function component 59 instance name to get the function component 59 23 instance obj ect 24 ~ If there is a qualification path ~ Then evaluate the qualification path by calling get methods on each of the elements 26 of the qualification path 27 ~ Now there should be a value for the prerequisite data element 28 ~ After all processing is complete, the value EVAL-PAGE is returned.

Public Class.P:,~e~exWa~.~c~,uPxc~d~~:e.Pa~e~'a~

1 (00212] This class implements the custom JSP tag extension library for presentation component 2 161 support for producing the output page.
3 Public get/set Methods 4 (00213] Every attribute of the tag has an associated get and set method. In particular, the following methods are created.
6 .getPage ( ) , setPage ( ) 7 (00214] Although the invention has been described with reference to certain specific S embodiments, various modifications thereof will be apparent to those skilled in the art without 9 departing from the spirit and scope of the invention as outlined in the claims appended hereto.
_~g_

Claims

1. A method for hosting a computer executable multi-tier application for interaction over a network with a user interface, the application including an application presentation tier, the method comprising the steps of:
selecting a first presentation template, the first template including a first presentation instruction for defining a corresponding first presentation element;
selecting a first presentation component of the application presentation tier for processing the first presentation instruction; and, linking the first presentation component to the first template, wherein the first component processes the first presentation instruction and generates the first presentation element during execution of the multi-tier application for subsequent delivery to the user interface.

2. The method of claim 1 further comprising the additional steps of:
selecting a second presentation template, the second template including a second presentation instruction for defining a corresponding second presentation element;
selecting the first presentation component for processing the second presentation instruction;
and, linking the first component to the second template, wherein the first component processes the second presentation instruction and generates the second presentation element during execution of the multi-tier application for subsequent delivery to the user interface.

3. The method of claim 1, wherein the multi-tier application further includes an application logic tier.

4. The method of claim 1, wherein the method comprises the additional steps of:
selecting an input datum;

selecting a first function component of the application logic tier for processing the input datum; and, linking the input datum to the first function component, wherein the first function component processes the input datum and generates an output datum during execution of the multi-tier application.

5. The method of claim 4, wherein the first template further comprises an output data presentation instruction for further defining the corresponding first presentation element to include the output datum.

6. The method of claim 5 comprising the additional step of:
directing the first presentation component to process the output datum presentation instruction, wherein the first presentation component processes the output datum presentation instruction and generates the first presentation element incorporating the output datum during execution of the multi-tier application.

7. The method of claim 2, wherein the presentation templates are computer readable files.

8. The method of claim 7, wherein the presentation instructions are selected from the group comprising: layout, style and format of the first presentation element.

9. The method of claim 8, wherein the presentation instructions are written in a markup language.

10. The method of claim 9, wherein the markup language is selected from the group comprising:
HTML, HDML and WML.

11. The method of claim 5, wherein the output datum presentation instruction defines a control within which the output datum is presented.

12. The method of claim 11, wherein the control is selected from the group comprising of Text field, Password field, Hidden field, Text area, Table, List box, Check box, Radio button, Image, Push button, Image button, Submit button, Reset button, Link and Span.

13. The method of claim 1, wherein the first presentation component is a computer executable file.

14. The method of claim 13, wherein the computer executable file is a java bean.

15. The method of claim 4, wherein the first function component is a computer executable file.

16. The method of claim 15, wherein the computer executable file is a java bean.

17. The method of claim1, wherein the first presentation component is linked to the first presentation template by a direction element.

18. The method of claim 17, wherein the direction element specifies the location of the first presentation template and directs the first presentation component to the specified location.

19. The method of claim 18, wherein the direction element is a first presentation component tag.

20. The method of claim 19, wherein the first presentation component tag is selected from the group comprising: page Tag; control Tag; attribute Tag; producePage Tag; clear Tag; and interceptor Tag.

21. The method of claim 19, wherein the first presentation component tag is expressed as a directive of a direction module, the direction module implementing the multi-tier application.

22. The method of claim 21, wherein the direction module is a java server page.

23. The method of claim 1, wherein the first function component is linked to the input datum by a direction element.

24. The method of claim 23, wherein the direction element specifies the location of the input datum and directs the first function component to the specified location.

25. The method of claim 24, wherein the direction element is a first function component tag.

26. The method of claim 25, wherein the first function component tag is selected from the group comprising: init Tag; call Tag; prerequisite Tag; debug Tag; error Tag;
getValue Tag; if Tag.

27. The method of claim 26, wherein the first function component tag is expressed as a directive of a direction module, the direction module implementing the multi-tier application.

28. The method of claim 21, wherein the direction module is a java server page.

29. The method of claim 1 further comprising the step of representing a display item on the user interface as a plurality of display portions, at least two of the portions associated with a different one of presentation templates.

30. The method of claim 29, wherein the presentation templates are reusable such that one of the templates is used to generate at least two of the portions.

31. A system for hosting a computer executable multi-tier application for interaction over a network with a user interface, the application including an application presentation tier, the system comprising:
a first presentation template, the first template including a first presentation instruction for defining a corresponding first presentation element;
a first presentation component of the application presentation tier for processing the first presentation instruction; and, a first direction element for linking the first presentation component to the first template;
wherein the first component processes the first presentation instruction and generates the first presentation element during execution of the multi-tier application for subsequent delivery to the user interface.

32. The system of claim 31 further comprising:
a second presentation template, the second template including a second presentation instruction for defining a corresponding second presentation element; and, a second direction element for linking the first component to the second template, wherein the first component processes the second presentation instruction and generates the second presentation element during execution of the multi-tier application for subsequent delivery to the user interface.

33. The system of claim 31, wherein the multi-tier application further includes an application logic tier.

34. The system of claim 31 further comprising:
a first function component of the application logic tier for processing an input datum; and, the first direction element further linking the input datum to the first function component, wherein the first function component processes the input datum and generates an output datum during execution of the multi-tier application.

35. The system of claim 34, wherein the first template further comprises an output data presentation instruction for further defining the corresponding first presentation element to include the output datum.

36. The system of claim 35, wherein the first presentation component processes the output datum presentation instruction and generates the first presentation element incorporating the output datum during execution of the multi-tier application.

37. The system of claim 32, wherein the presentation templates are computer readable files.

38. The system of claim 37, wherein the presentation instructions are selected from the group comprising: layout, style and format of the first presentation element.

39. The system of claim 38, wherein the presentation instructions are written in a markup language.

40. The system of claim 39, wherein the markup language is selected from the group comprising:
HTML, HDML and WML.

41. The system of claim 35, wherein the output datum presentation instruction defines a control within which the output datum is presented.

42. The system of claim 41, wherein the control is selected from the group comprising of Text field, Password field, Hidden field, Text area, Table, List box, Check box, Radio button, Image, Push button, Image button, Submit button, Reset button, Link and Span.

43. The system of claim 41, wherein the first presentation component is a computer executable file.

44. The system of claim 43, wherein the computer executable file is a Java bean.

45. The system of claim 34, wherein the first function component is a computer executable file.

46. The system of claim 45, wherein the computer executable file is a Java bean.

47. The system of claim 31, wherein the first presentation component is linked to the first presentation template by a direction element.

48. The system of claim 47, wherein the direction element specifies the location of the first presentation template and directs the first presentation component to the specified location.

49. The system of claim 48, wherein the direction element is a first presentation component tag.

50. The system of claim 49, wherein the first presentation component tag is selected from the group comprising: page Tag; control Tag; attribute Tag; producePage Tag; clear Tag; and interceptor Tag.

51. The system of claim 49, wherein the first presentation component tag is expressed as a directive of a direction module, the direction module implementing the multi-tier application.

52. The system of claim 51, wherein the direction module is a java server page.

53. The system of claim 31, wherein the first function component is linked to the input datum by a direction element.

54. The system of claim 53, wherein the direction element specifies the location of the input datum and directs the first function component to the specified location.

55. The system of claim 54, wherein the direction element is a first function component tag.

56. The system of claim 55, wherein the first function component tag is selected from the group comprising: init Tag; call Tag; prerequisite Tag; debug Tag; error Tag;
getValue Tag; if Tag.

57. The system of claim 56, wherein the first function component tag is expressed as a directive of a direction module, the direction module implementing the multi-tier application.

58. The system of claim 51, wherein the direction module is a java server page.