Oracle JavaServer Pages Developer's Guide and Reference Release 8.1.7 Part Number A83726-01 |
Library | Service | Contents | Index

## JML Compile-Time/1.0.0.6.x Tag Support

This section presents the following:

- a summary of all compile-time tags, noting which are desupported in the runtime implementation

- a description of tags supported by the compile-time implementation that are desupported in the runtime implementation (because such tags are not documented in "JSP Markup Language (JML) Tag Descriptions")

  Note: In most cases, JML tags that are desupported in the runtime implementation have standard JSP equivalents. Some of the compile-time tags, however, were desupported because they have functionality that is difficult to implement when adhering to the JSP 1.1 specification.

### JML Tag Summary, 1.0.0.6.x/Compile-Time Versus 1.1.0.0.0/Runtime

Most JML tags are available in both the runtime model and the compile-time model; however, there are exceptions, as summarized in Table C-1.

##### Table C-1 JML Tags Supported: Compile-Time Model Versus Runtime Model

Tag | Supported in OracleJSP Compile-Time Implementation? | Supported in OracleJSP Runtime Implementation?
--- | --- | ---
Bean Binding Tags: |  |
useBean | yes | no; use `jsp:useBean`
useVariable | yes | yes
useForm | yes | yes
useCookie | yes | yes
remove | yes | yes
Bean Manipulation Tags |  |
getProperty | yes | no; use `jsp:getProperty`
setProperty | yes | no; use `jsp:setProperty`
set | yes | no
call | yes | no
lock | yes | no
Control Flow Tags |  |
if | yes | yes
choose | yes | yes
for | yes | yes
foreach | yes; `type` attribute is optional | yes; `type` attribute is required
return | yes | yes
flush | yes | yes
include | yes | no; use `jsp:include`
forward | yes | no; use `jsp:forward`
XML Tags |  |
transform | yes | yes
styleSheet | yes | yes
Utility Tags |  |
print | yes; use double-quotes to specify a string literal | no; use JSP expressions
plugin | yes | no; use `jsp:plugin`

### Descriptions of Additional JML Tags, Compile-Time Implementation

This section provides detailed descriptions of JML tags that are still supported by the JML compile-time implementation, but are not supported by the JML runtime implementation. These tags are not documented under "JSP Markup Language (JML) Tag Descriptions".

In summary, this consists of the following JML tags.

- JML useBean Tag

- JML getProperty Tag

- JML setProperty Tag

- JML set Tag

- JML call Tag

- JML lock Tag

- JML include Tag

- JML forward Tag

- JML print Tag

- JML plugin Tag

For the syntax documentation in the tag descriptions, note the following:

- Italics indicate you must specify a value or string.

- Optional attributes are enclosed in square brackets: `[...]`

- Default values of optional attributes are indicated in bold.

- Choices in how to specify an attribute are separated by vertical bars: |

- The prefix "jml:" is used. This is by convention, but is not required. You can specify any desired prefix in your `taglib` directive.

#### JML useBean Tag

This tag declares an object to be used in the page, locating the previously instantiated object at the specified scope by name if it exists. If it does not exist, the tag will create a new instance of the appropriate class and attach it to the specified scope by name.

The syntax and semantics are the same as for the standard `jsp:useBean` tag, except that wherever a JSP expression is valid in `jsp:useBean` usage, either a JML expression or a JSP expression is valid in JML `useBean` usage.

##### Syntax

    <jml:useBean id = "beanInstanceName"
                 scope ="page | request | session | application"
                 class ="package.class" | type = "package.class" |
                 class ="package.class" type = "package.class" |
                 beanName = "package.class | <%= jmlExpression %>"
                 type = "package.class" />

Alternatively, you can have additional nested tags, such as `setProperty` tags, and use a `</jml:useBean>` end tag.

##### Attributes

Refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1 for information about attributes and their syntax.

##### Example

    <jml:useBean id = "isValidUser" class = "oracle.jsp.jml.JmlBoolean" scope = "session" />

#### JML getProperty Tag

This tag is functionally identical to the standard `jsp:getProperty` tag. It prints the value of the bean property into the response.

For general information about `getProperty` usage, refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1.

##### Syntax

    <jml:getProperty name = "beanInstanceName" property = "propertyName" />

##### Attributes

- `name`--This is the name of the bean whose property is being retrieved. This attribute is required.

- `property`--This is the name of the property being retrieved. This attribute is required.

##### Example

The following example outputs the current value of the `salary` property. (Assume `salary` is of type `JmlNumber`.)

    <jml:getProperty name="salary" property="value" />

This is equivalent to the following:

    <%= salary.getValue() %>

#### JML setProperty Tag

This tag covers the functionality supported by the standard `jsp:setProperty` tag, but also adds functionality to support JML expressions. In particular, you can use JML bean references.

For general information about `setProperty` usage, refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1.

##### Syntax

    <jml:setProperty name = "beanInstanceName"
            property = " * " |
            property = "propertyName" [ param = "parameterName" ] |
            property = "propertyName"
            value = "stringLiteral | <%= jmlExpression %>" />

##### Attributes

- `name`--This is the name of the bean whose property is being set. This attribute is required.

- `property`--This is the name of the property being set. This attribute is required.

- `value`--This is an optional parameter that lets you set the value directly instead of from a request parameter. The JML `setProperty` tag supports JML expressions in addition to standard JSP expressions to specify the value.

##### Example

The following example updates `salary` with a six percent raise. (Assume `salary` is of type `JmlNumber`.)

    <jml:setProperty name="salary" property="value" value="<%= $[salary] * 1.06 %>" />

This is equivalent to the following:

    <% salary.setValue(salary.getValue() * 1.06); %>

#### JML set Tag

This tag provides an alternative for setting a bean property, using syntax that is more convenient than that of the `setProperty` tag.

##### Syntax

    <jml:set name = "beanInstanceName.propertyName"
             value = "stringLiteral | <%= jmlExpression %>" />

##### Attributes

- `name`--This is a direct reference (JML bean reference) to the bean property to be set. This attribute is required.

- `value`--This is the new property value. It is expressed either as a string literal, a JML expression, or a standard JSP expression. This attribute is required.

##### Example

Each of the following examples updates `salary` with a six percent raise. (Assume `salary` is of type `JmlNumber`.)

    <jml:set name="salary.value" value="<%= salary.getValue() * 1.06 %>" />

or:

    <jml:set name="salary.value" value="<%= $[salary.value] * 1.06 %>" />

or:

    <jml:set name="salary" value="<%= $[salary] * 1.06 %>" />

These are equivalent to the following:

    <% salary.setValue(salary.getValue() * 1.06); %>

#### JML call Tag

This tag provides a mechanism to invoke bean methods that return nothing.

##### Syntax

    <jml:call method = "beanInstanceName.methodName(parameters)" />

##### Attributes

- `method`--This is the method call as you would write it in a scriptlet, except that the `beanInstancename.methodName` portion of the statement can be written as a JML bean reference if enclosed in JML expression `$[... ]` syntax. This attribute is required.

##### Example

The following example redirects the client to a different page:

    <jml:call name='response.sendRedirect("http://www.oracle.com/")' />

This is equivalent to the following:

    <% response.sendRedirect("http://www.oracle.com/"); %>

#### JML lock Tag

This tag allows controlled, synchronous access to the named object for any code that uses it within the tag body.

Generally, JSP developers need not be concerned with concurrency issues. However, because application-scoped objects are shared across all users running the application, access to critical data must be controlled and coordinated.

You can use the JML `lock` tag to prevent concurrent updates by different users.

##### Syntax

    <jml:lock name = "beanInstanceName" >
       ...body...
    </jml:lock>

##### Attributes

- `name`--This is the name of the object that should be locked during execution of code in the `lock` tag body. This is a required attribute.

##### Example

In the following example, `pageCount` is an application-scoped `JmlNumber` value. The variable is locked to prevent the value from being updated by another user between the time this code gets the current value and the time it sets the new value.

    <jml:lock name="pageCount" >
        <jml:set name="pageCount.value" value="<%= pageCount.getValue() + 1 %>" />
    </jml:lock>

This is equivalent to the following:

    <% synchronized(pageCount)
       {
          pageCount.setValue(pageCount.getValue() + 1);
       }
    %>

#### JML include Tag

This tag includes the output of another JSP page, a servlet, or an HTML page in the response of this page (the page invoking the `include`). It provides the same functionality as the standard `jsp:include` tag except that the `page` attribute can also be expressed as a JML expression.

##### Syntax

    <jml:include page = "relativeURL | <%= jmlExpression %>" flush = "true" />

##### Attributes

For general information about `include` attributes and usage, refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1.

##### Example

The following example includes the output of `table.jsp`, a presentation component that renders an HTML table, based on data in the query string and request attributes.

    <jml:include page="table.jsp?maxRows=10" flush="true" />

#### JML forward Tag

This tag forwards the request to another JSP page, a servlet, or an HTML page. It provides the same functionality as the standard `jsp:forward` tag except that the `page` attribute can also be expressed as a JML expression.

##### Syntax

    <jml:forward page = "relativeURL | <%= jmlExpression %>" />

##### Attributes

For general information about `forward` attributes and usage, refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1.

##### Example

    <jml:forward page="altpage.jsp" />

#### JML print Tag

This tag provides essentially the same functionality as a standard JSP expression: `<%=` `expr``%>`. A specified JML expression or string literal is evaluated, and the result is output into the response. With this tag, the JML expression does not have to be enclosed in `<%= ... %>` syntax; however, a string literal must be enclosed in double-quotes.

##### Syntax

    <jml:print eval = '"stringLiteral"' | "jmlExpression" />

##### Attributes

`eval`--Specifies the string or expression to be evaluated and output. This attribute is required.

##### Examples

Either of the following examples outputs the current value of `salary`, which is of type `JmlNumber`:

    <jml:print eval="$[salary]"/>

or:

    <jml:print eval="salary.getValue()" />

The following example prints a string literal:

    <jml:print eval='"Your string here"' />

#### JML plugin Tag

This tag has functionality identical to that of the standard `jsp:plugin` tag.

For information about `plugin` attributes, usage, and examples, refer to the Sun Microsystems JavaServer Pages Specification, Version 1.1.

| Copyright © 1996-2000, Oracle Corporation. All Rights Reserved. |
Library | Service | Contents | Index