The Java part of the component must implement the com.systinet.webfw.Component interface from the Web Framework library. However, it usually extends its default implementation: com.systinet.webfw.ComponentImpl. For those components that do not declare their Java part, this default implementation is automatically used.

The interface consists of two methods:

The process() method is called just before the translation of the component's JSP part is started, so it should take care of data preparation and it should also handle the actions requested by the user (react to pressed buttons, etc.).

The populate() method is called only when the POST request to the URI comes from the same URI , so it's a perfect place to modify the way data from a web page is populated back into objects. Actually, the target objects are always Java Beans which simplify their handling quite a bit.

Request Diagram  ^Locate

The diagram shown in Figure 12 demonstrates how requests for the page are handled by the Web Framework:

Figure 12. Request Diagram

1. The request is sent by the client browser from a different page than the page requested.

2. The process() method is called on taskA component's Java part. This method should perform actions triggered by controls in the web page and/or prepare data for taskA component's JSP part.

3. Processing of taskA component's JSP part is initialized.

4. While taskA component's JSP part is being processed, the resulting HTML is generated.

5. Processing of taskA component's JSP part finishes; the response is returned to the client's browser.

	Note
	If the request is sent by the client browser from the same page as the page requested (meaning the source and target tasks are the same), then the populate() method is called on the task component's Java part before the process() method.

Nesting Components  ^Locate

As we noted above, the component JSP part can include other components using the syswf:component custom tag right in the JSP code. The diagram shown in Figure 13 presents how a request is handled when there are such nested components. Note that now the request comes from the same task it is targeted to:

Figure 13. Nesting Components Diagram

1. The request is sent by the client browser from the same page as the page requested.

2. The populate() method is called on taskA component's Java part. This method is responsible for the transfer of data from web page form elements (input fields, radio buttons, etc.) to JavaBeans objects on the server.

3. The process() method is called on taskA component's Java part. This method should perform actions triggered by controls in the web page and/or prepare data for taskA component's JSP part.

4. Processing of taskA component's JSP part is initialized.

5. Request for insertion of component A is found.

6. The process() method is called on the Java part of component A. This method should prepare data for component presentation.

7. Processing of the JSP part of component A is performed. Once finished, the result is included in the parent JSP page.

8. Request for insertion of component B is found.

9. The process() method is called on the Java part of component B. This method should prepare data for component presentation.

10. Processing of the JSP part of component B is performed. Once finished, the result is included in the parent JSP page.

11. Processing of taskA component's JSP part finishes. The response is returned in the client's browser.

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<%@ taglib prefix="syswf" uri="http://systinet.com/jsp/syswf" %>

<syswf:page headerTemplate="pageHeader.jsp" footerTemplate="pageFooter.jsp">

    <syswf:wrap headerTemplate="design/pageHeader.jsp" 
        footerTemplate="design/pageFooter.jsp">
    ...
    </syswf:wrap>

</syswf:page>
                

The core of the JSTL (standard tag library) together with the Registry Web Framework custom tag library are imported. The beginning of the page is declared ( syswf:page tag); page header and footer represented as JSP pages are passed as attributes. These pages contain the basic HTML tags and declaration of Java Scripts that will be used in the page.

To enable automatic wrapping and resizing, all of the page's content is packed into the syswf:wrap tag to which page header and footer JSP pages are passed as attributes. The header and footer pages contain:

Implicit objects allow you to interact with various framework parts, from Java code or JSP pages. A reference to an implicit object should be obtained from the com.systinet.uddi.util.CallContext class, or by using simple getter methods from com.systinet.webfw.ComponentImpl.

Data type classes are responsible for converting values between web page HTML form fields and underlying Java Beans objects. The Data type class must implement the simple interface com.systinet.webfw.datatype.DataType with two methods:

There are predefined implementations of this object for converting the simple Java data types string, int, long, and boolean.

Validators can be used to validate user input before a web page is submitted to a server. The validation is invoked by a specific page control (a button or a link). There is a predefined set of validators for common input field checks.

To add a validator to an input field or a text area, use the sysfw:checker tag. To trigger the validation control, use the syswf:validate tag.

<syswf:input name="businessKey" value="">
    <syswf:checker name="required" action="viewBusinessV3"/>
    <syswf:checker name="uddiKey" action="viewBusinessV3"/>
</syswf:input> 
...
<syswf:control action="viewBusiness" caption="View business" mode="button">
    <syswf:validate action="viewBusinessV3"/>
</syswf:control>

The Example 18 shows an input field with two checkers, the first one checks if the field is not empty and the second one checks if the field contains a string starting with the prefix uddi: (uddi key). Both checkers are invoked when a user clicks the View business button.

Validation is performed using a JavaScript function. The validator name is required to be defined in the JavaScript function with the name check_required. The return value from the validator is of the boolean type: true when the field content is valid, and false when content is invalid. In case of error, the validator displays an error message with the description of the allowed field content. This validator is also responsible for transferring the focus to the field with an error.

// is required checker
function check_required (formID, fieldID)
{
  var value = getFieldValue(formID, fieldID);
  if (isEmpty(value))
  {
    alertRequired();
    setFocus(formID, fieldID);
    return false;
  }
  return true;
}

Custom validators should be can be added to the file REGISTRY_HOME/app/uddi/web.jar/webroot/script/uddi.js. Many functions for validation are defined in the file REGISTRY_HOME/app/uddi/web.jar/webroot/script/wf.js.

Specifies configuration of page components.

Contains definition of tasks.

Contains the definition of the data types.

Includes the component with specified parameters.

The value of the parameter should be specified in two ways: As a value attribute or as a content of the value tag.

<syswf:component prefix="names" name="nameList">
   <syswf:param name="color1" value="white"/>
   <syswf:param name="color2">black</syswf:param>
</syswf:component> 
                    

Creates an HTML page form with all required internal fields. This must be the root element of all components used as tasks.

This tag helps you to separate page functionality from its design. It includes specified header and footer templates before and after the body element. Header and footer templates should be parametrized using syswf:param tags.

Creates a button or link, which should be used to trigger actions and transfers to other tasks.

Inserts input field into JSP page.

Displays controls which enable the user to select one value from a list of available values.

Displays controls which enable the user to select multiple values from list of available values.

Creates a text area HTML component.

Evaluates the given expression and transform result using data type.

This tag will fill the page attribute with size of given List, UDDIList, StringArrayList or Array.

This component renders the history path (bread crumbs links)

navigationPath component in action

                <syswf:component name="navigationPath" prefix="path"/>