Caucho maker of Resin Server | Application Server (Java EE Certified) and Web Server


 

Resin Documentation

home company blog wiki docs 
app server web server 
health cloud java ee pro 
 Resin Server | Application Server (Java EE Certified) and Web Server
 

actions


Actions are the core of JSP. Actions range from printing a script expression, to creating and storing a Java Bean.

JSP Lexical

escapes

The JSP actions can be escaped using <\%.

<\% verbatim text %>
<% verbatim text %>

whitespace

JSP whitespace is copied to the output directly, unless escaped.

In Resin 1.2, if you place a backslash immediately after a JSP action and before a line end, Resin will omit the end of line. In the following example, Resin keeps the whitespace after the <%@page ... %> and removes it after after the <%= 2 + 2 %>.

<% @page session="true" %>
a
<%= 2 + 2 %>\
c

a
4c

JSP Actions

<%@ name att1="v1"... %>

Sets a JSP directive

<%= expression %>

Prints the value of expression evaluated the page's language.

The expression action is equivalent to the following:

  out.print(expression);

It also has the following XML equivalent

<jsp:expression>
  expression
</jsp:expression>

The following simple example just prints the value of a form variable.

Name: <%= request.getParameter("name") %>
Name: George Washington

<% scriptlet %>

Executes the statements in scriptlet using the page's language.

The scriptlet is any statement list in the language, e.g. Java. The scriptlet can use any of the implicit variables, such as the request object and the out writer.

Scriptlets have the following XML equivalent

<jsp:scriptlet>
  scriptlet
</jsp:scriptlet>
<h1>Form results</h1>

<pre>
<%
  Enumeration e = request.getParameterNames();
  while (e.hasMoreElements()) {
    String key = e.nextElement();
    String value = request.getParameter(key);

    out.println(key + ": " + value);
  }
%>
</pre>
<h1>Form results</h1>

<pre>
  Name: George Washington
  Rank: General
</pre>

<%! declaration %>

Adds declaration code to the Servlet class

JSP places the declaration code in the servlet class. In contrast, scriptlet and expression code are in a service method. So declarations can declare class variables and methods.

note
Note
Declarations are primarily useful for Java, but are allowed in JavaScript.

Declarations have the following XML equivalent

<jsp:declaration>
  declaration
</jsp:declaration>
<%= foo() %>

<%!
  private int foo() { return 1329; }
%>

<jsp:include page="path"/>

Includes the contents of the local URL at path during runtime.

jsp:include is a runtime action. It will call the included path just as if path its own HTTP request. The result of that page will be included in the current page.

path is relative to the current page. Its root is the root of the application.

For compile-time includes, use <%@ include file='path'%>

inc.jsp
<%= 2 + 2 %>
test.jsp
Header
<jsp:include page='inc.jsp'/>
Footer
Header
4
Footer

<jsp:forward page="path" />

Forwards the request to another page, i.e. an internal redirect.

If the page has already written some output, jsp:request will clear the output buffer.

path is relative to the current page.

fwd.jsp
<%= 2 + 2 %>
test.jsp
Header
<jsp:forward page='inc.jsp'/>
Footer
4

<jsp:useBean id="name" ...>...

Creates a new bean and variable for the page.

ATTRIBUTEVALUEMEANING
id The variable name for the bean
class The bean's Java class
scope  
 pageOnly active in the page, stored in pageContext
 requestActive for the request, stored in request
 sessionActive for the session, stored in session
 applicationActive for the application, stored in application

jsp:useBean enables a popular style JSP page creation where Java Beans calculate the content, and JSP formats the presentation.

jsp:useBean creates an initializes a JSP bean for the page. The scope attribute determines the bean lifetime. For example, a session bean will be created once in a session.

jsp:useBean assigns the bean to the variable name. It will also store the bean in the appropriate scope variable. For example, an application bean "foo" will be stored in the application variable.

jsp:useBean can also initialize beans. When jsp:useBean creates a new bean, it will execute the JSP in the jsp:useBean tag.

Roughly, JSP makes the following translation:

<jsp:useBean id='foo' 
                class='com.caucho.test.TestBean' 
                scope='session'>
  <% foo.myInitialization("test"); %gt;
</jsp:useBean>
com.caucho.test.TestBean foo;
foo = (com.caucho.test.TestBean) session.getValue("foo");
if (foo == null) {
  foo = new com.caucho.test.TestBean();
  session.value.foo = foo;
  foo.myInitialization("test");
}

<jsp:getProperty name="name" ... />

Prints a bean property.

ATTRIBUTEMEANING
nameThe variable name for the bean
propertyThe property name to retrieve.

jsp:getProperty converts property names following the bean standards.

Roughly, jsp:getProperty makes the following conversion:

<jsp:getProperty name='foo' property='bar'/>
out.print(foo.getBar());

<jsp:setProperty ... value="value"/>

Sets a bean property to value.

ATTRIBUTEMEANING
nameThe variable name for the bean
propertyThe property name to set.
valueThe value to set.

If value is a runtime attribute, the bean property gets the expression value. If it's a static string, the value is first converted to the argument type and then set.

<jsp:setProperty name='foo' property='count' value='10'/>
foo.setCount(10);
<jsp:setProperty name='foo' property='string' value='10'/>
foo.setString("10");
<jsp:setProperty name='foo' property='count' value='<%= 2 + 2 %>'/>
foo.setCount(2 + 2);
<jsp:setProperty name='foo' property='count' value='2 + 2'/>
error
<jsp:setProperty name='foo' property='char' value='10'/>
foo.setChar('1');

<jsp:setProperty ... param="param"/>

Sets a bean property to a parameter value.

ATTRIBUTEVALUEMEANING
name The variable name for the bean
propertypropertyThe property name to set.
 *Set all properties
paramparamThe form parameter to use as a value.
 emptyIf missing, use property

The second form of jsp:setProperty lets scripts easily set Bean properties to form values.


Copyright © 1998-2012 Caucho Technology, Inc. All rights reserved. Resin ® is a registered trademark. Quercustm, and Hessiantm are trademarks of Caucho Technology.

Cloud-optimized Resin Server is a Java EE certified Java Application Server, and Web Server, and Distributed Cache Server (Memcached).
Leading companies worldwide with demand for reliability and high performance web applications including SalesForce.com, CNET, DZone and many more are powered by Resin.

home company blog wiki docs 
app server web server 
health cloud java ee pro