What's the difference between # , % and $ signs in Struts tags?

Question

I'm working with Struts 2 and when I'm accessing ValueStack variables I don't know whether to use % or # or $. I try all of them until I find the correct one.

Can anybody explain what is the difference between them?

Answer 1

Use of # (pound sign)

OGNL is used to refer to objects in the ActionContext as follows:

• objectName: object in the ValueStack (default/root object in the OGNL context), such as an Action property
• #objectName: object in the ActionContext but outside of the ValueStack, specifically...
  • #objectName: ActionContext object that has been created using the Struts2 data tags with the default action scope (e.g., <s:set name="foo" value="'Testing'" />, referenced by <s:property value="#foo" />)
  • #parameters.objectName: request parameter
  • #request.objectName: request-scoped attribute
  • #session.objectName: session-scoped attribute
  • #application.objectName: application-scoped attribute
  • #attr.objectName: attribute in page, request, session, or application scope (searched in that order)

The scoped map references above (parameters, request, session, and application) can be made one of two ways:

• #scopeName.objectName or
• #scopeName['objectName']

Use of % (percent sign)

%{ OGNL expression } is used to force OGNL evaluation of an attribute that would normally be interpreted as a String literal.

Example: <s:property value="myProperty" default="%{myDynamicDefaultValue}" />

Use of @ (at sign)

The @ symbol is used to make references to static properties and methods. Note that you may need to enable this in your Struts2 properties: struts.ognl.allowStaticMethodAccess=true

Examples:

@my.package.ClassName@MY_STATIC_PROPERTY
@my.package.ClassName@myStaticMethod

Use of $ (dollar sign)

Struts2 OGNL does not make special use of the dollar sign. However, it can be used to evaluate normal JSTL expressions. For example:

Struts2: <h1><s:property value="#pageTitle" /></h1>
(is equivalent to...)
JSTL: <h1>${pageTitle}</h1>

Answer 2

The framework uses a standard naming context to evaluate OGNL expressions. The top level object dealing with OGNL is a Map (usually referred as a context map or context). OGNL has a notion of there being a root (or default) object within the context. In expression, the properties of the root object can be referenced without any special "marker" notion. References to other objects are marked with a pound sign (#).

The framework sets the OGNL context to be our ActionContext, and the value stack to be the OGNL root object. (The value stack is a set of several objects, but to OGNL it appears to be a single object.) Along with the value stack, the framework places other objects in the ActionContext, including Maps representing the application, session, and request contexts. These objects coexist in the ActionContext, alongside the value stack (our OGNL root).

                 |
                 |--application
                 |
                 |--session
   context map---|
                 |--value stack(root)
                 |
                 |--request
                 |
                 |--parameters
                 |
                 |--attr (searches page, request, session, then application scopes)

refer this for more details

OGNL basis

basically struts2 put object value Stack as top most object and OGNL is used to refer them.root object can be referenced without any special "marker" or with % while References to other objects are marked with a pound sign (#). # is basically used to refer object/values from Application/Session etc.