Tags Overview & Generic Tags

The Struts TLD is inside struts2-core-7.4.0.jar as META-INF/struts-tags.tld, so a page only needs the directive; no web.xml entry and no WEB-INF/tlds copy:

Source: Tag Developer Guide — JSP Tags, Tag Library Definition (TLD)

Requested through the shelf action this prints Filter: all and one <li> per title. The facts of the descriptor that decide how the tags behave, read from the 7.4.0 jar:

Source: Tag Developer Guide — Tag Syntax, Expression Language Notations

The attribute rtexprvalue=false explains the most frequent question about Struts tags: <s:property value="${filter}"/> fails at translation, because ${...} is JSP EL and the attribute accepts no JSP expressions. The expression is OGNL, and a %{...} marks it when the attribute is a string. The ValueStack, ActionContext & OGNL page shows the failure and the reason in detail.

Every expression of every tag is OGNL evaluated against the value stack of the request: a bare name is a property looked up from the top of the stack downwards (the action first, then whatever push, bean or iterator put above it), and a name with a # in front is a key of the context map (#session, #request, #attr, #parameters and the variables created by set, iterator and the other tags with a var attribute). The ValueStack, the ActionContext and OGNL are the subject of the ValueStack, ActionContext and OGNL page; the short version that the tags need is the next table.

Source: Tag Developer Guide — OGNL, Referencing an Action property

The experiment that shows rule 1 uses s:textfield with theme="simple", which renders just the <input> element and no table row (themes belong to the page on themes and templates). The same action property filter (value all) is written five ways, and the HTML of each is quoted:

Source: Tag Developer Guide — Tag Syntax, The value attribute of form tags

The first line gets its value without a value attribute at all, because name tells the tag which property to read (and to write back on submission). The second prints the literal text filter: value of a form tag is a String attribute, so filter is a literal, not a property name. The third reads the property with the notation. The fourth calls a method of the action (getText is inherited from ActionSupport) and the fifth mixes literal text with two expressions, which is what the notation is for.

The most common use of the same rule is a label that comes from a message bundle or contains data:

The labels rendered (the xhtml theme wraps each field in a table row; only the <label> element is quoted):

Source: Tag Developer Guide — Tag Syntax, Using an expression to set the label

The second label is the trap: label is a String attribute, so without the notation getText('book.heading') is literal text and prints as it was written. The Text tag page of the Tag Developer Guide shows exactly that form, label="getText('person.lastName')", as the way to use i18n in an attribute; on Struts 7.4.0 it prints the call, and the working form needs %{...} around it.

Rule 2 is the reason that test=count  3 works without any notation on s:if, and that multiple="true" on a select is a boolean. The Tag Syntax page gives four spellings of the same boolean; the example WAR renders them with a s:select (the multi-select attribute multiple is a boolean), and the HTML shows that the first two are multiple selects and the last two follow the action property allowMulti, which is false:

Source: Tag Developer Guide — Tag Syntax, Non-String Attributes

The list attribute of the same tag is a non-String attribute too: list="genres" is the OGNL expression genres, the Map of the action. Because it is easy to forget which attributes are Strings, the notation is harmless on the non-String ones, and most Struts code writes %{...} everywhere an expression is meant; the official examples of the generic tags, though, write test="#rowstatus.odd == true" and value="users" without it, and so does this page.

The attributes of the data tags are the ones that show rule 1 and rule 2 side by side. s:property takes value as an Object (rule 2: an expression), s:set also treats value as an expression, as every set example of the guide shows. The six lines below were requested and printed on the page syntax:

Source: Tag Developer Guide — property tag, Examples

The pair C1 and C2 is the difference between a property name and an OGNL string literal: single quotes make a literal, exactly as they did in the pre-2.2 syntax described next. s:set shows the same behaviour with the var: <s:set var="lit" value="filter"/> stores all, value="'filter'" stores the text filter and value="%{filter}" stores all again (page data, line S7).

The page named Alt Syntax in the Tag Developer Guide is now a history page, and it is the reason that older books and blog posts look different. Before WebWork 2.1.4 every attribute was evaluated as an OGNL expression, so a literal needed single quotes; the altSyntax option made only %{...} evaluate. It was on by default from WebWork 2.2 and a struts.xml constant and a per-request flag could switch it off. Struts 2.6 removed both (WW-3877), so the %{...} notation is the only syntax. The guide’s own before-and-after example is the clearest summary:

Source: Tag Developer Guide — Alt Syntax, History

A page copied from an old example in which value="note" was supposed to read the property note prints the literal text note on Struts 7.4.0 (the third line of the experiment above), and a ${...} of the same era is JSP EL, which a Struts attribute does not accept.

The Tag Syntax page lists seven property names as disallowed: parameters, application, session, struts, request, servletRequest and servletResponse; its example, <s:iterator value="parameters"/> on an action with a getParameters() getter, "will not work". On Tomcat 11.0.26 with Struts 7.4.0 an action with String[] getParameters() was read normally:

Source: Tag Developer Guide — Tag Syntax, Disallowed property names

The bare name resolves on the stack, the action is on the stack, so its property wins. The names are still a poor choice: they are the names of the context map’s own objects, and #parameters, #session and #request with a # mean something else on the same page; the rule to keep is not to give an action a property that has the name of a context object.

A quirk of OGNL deserves its own paragraph because it is the oldest question about the if tag (the guide’s FAQ has it). In OGNL a single-quoted literal of one character is a char, not a String. Comparing the string a of the action to the literal 'a' is therefore false:

Source: Tag Developer Guide — Struts Tags, FAQs (the one-char string question)

The cure given by the FAQ is to flip the quotes: double quotes inside single quotes make a String. The same applies to every test or value with a one-character literal; a literal of two or more characters is a String and needs no care.

JSP EL and OGNL live side by side on a page and do not read the same objects: ${...} is evaluated by the JSP container and works in template text and in the attributes of JSP or JSTL tags, while OGNL works only in Struts tag attributes. The Tag Syntax page lists the forms: ${user.username} reads a JavaBean in a standard context (JSTL, FreeMarker or Velocity), <s:textfield name="username"/> reads a property on the stack, and #{'a':'b'} is a literal map. How ${filter} reaches the value stack (the request wrapper that falls back to the stack), why <s:property value="${x}"/> fails and what changes with escaping is the subject of the value stack page; the section on JSTL below shows the combinations that work.

Source: Tag Developer Guide — Tag Syntax, Expression Language Notations

Since Struts 2.6 and the FreeMarker version that enables auto-escaping by default, the guide says to stop using ?html in custom tags and FreeMarker pages. For the tags whose body is markup the library offers escapeHtmlBody: it exists on a, submit and component, and the global constant struts.ui.escapeHtmlBody sets it for all three, with the attribute taking precedence over the constant. On the example page:

Source: Tag Developer Guide — Tag Syntax, Escaping body of a tag

if performs basic condition flow. It can stand alone or be followed by any number of elseif tags and one else; an elseif is only valid after an if and an else only after an if or elseif. The tag has one attribute besides the pooling one: test (required), a Boolean expression that decides whether the body is written.

Source: Tag Developer Guide — if tag, Attributes

The conversion to a boolean is the one of OGNL, and it is where the surprises are. Every line below was requested on the page control; the expressions and the output are:

Source: Tag Developer Guide — if tag, Examples

Read the outputs against the conversion rule of OGNL: a boolean expression is used as it is (IF1, IF2, IF7), in and not in test membership of a collection literal (IF8), a string that is not true converts to false, so a property that holds the text all is false (IF10), a single-quoted one-character literal is a char, which converts to true (IF11), the string 'true' converts to true (IF12) and any other string, 'aa', to false (IF13). The practical rule is to write a real boolean expression, a comparison or a boolean property, and never to rely on the truthiness of a string. The Getting Started tutorial on control tags uses the same tag with personBean.over21, a boolean getter, and with personBean.carModels.length > 1 to choose between "Car model" and "Car models".

Source: Getting Started — Control Tags, Struts if Tag

A second trap is the method call on a JDK collection. These tests were written the way a Java programmer would write them, and then the way OGNL needs them (page control, lines IF6 and IF9):

Source: Tag Developer Guide — OGNL, Collections (Maps, Lists, Sets)

The method forms print nothing and the log has Declaring class [class java.util.AbstractCollection] of member type [public abstract int java.util.AbstractCollection.size()] is not allowlisted; the property forms (books.size, noBooks.empty, books[0]) read the same data through the bean introspection that the allowlist permits. The reason and the alternative of allowlisting JDK classes are on the value stack page, which also explains why ! and not work as negation.

The if tag is the cure for logic in the page, not an invitation to put it there: a condition that is more than a comparison belongs in a boolean getter of the action (isOver21(), isEmpty()), which keeps the page readable and testable.

iterator loops over a value. The iterable can be any java.util.Collection, java.util.Iterator, java.util.Enumeration, java.util.Map or an array; the tag documentation adds that a value that is none of them is put into a newly created list (the loop then runs once). For each pass the current element is pushed on the value stack, so inside the loop the properties of the element are the bare names, and it is popped at the end of the pass.

Source: Tag Developer Guide — iterator tag, Attributes

The basic loops, with the output of the example action (page control, lines IT1 to IT4):

Source: Tag Developer Guide — iterator tag, Examples

IT1 iterates over a list of strings: <s:property/> with no value prints the top of the stack, which is the current string. IT2 iterates over beans and reads a property of the current one (label is getLabel() of Book, evaluated on the element because the element is on the stack). IT3 shows that var gives the element a second name: #b.title and title are the same book. The Getting Started tutorial on control tags builds a table the same way from the array personBean.carModels, and says that if the collection holds objects with several fields, value of the nested property selects the field.

Source: Getting Started — Control Tags, Struts iterator Tag

Five control tags create or transform iterators. Each one has a var that stores the result in the context (read with #name, and for sort, subset and generator also in the page context as the documentation says), and each one pushes the result on the stack for the duration of its body, so an iterator without a value inside it loops over the result.

Source: Tag Developer Guide — Generic Tags

The example action supplies a Comparator<Book> by year (getByYear()), a Decider for the genre scifi (getScifiOnly()) and a Converter that upper-cases (getUpper()); the output of each tag (page control):

Source: Tag Developer Guide — append tag, Example

Source: Tag Developer Guide — merge tag, Examples

Source: Tag Developer Guide — generator tag, Examples

Source: Tag Developer Guide — sort tag, Examples

Source: Tag Developer Guide — subset tag, Examples

Details that the examples settle:

The guide does not rank the iterator tags; this table does, from the experiments above and the Bookshelf’s needs.

Source: Tag Developer Guide — Generic Tags

property writes the value of an expression, converted to a string and HTML-escaped. It is the tag of every page of this section and the one with the most useful attributes.

Source: Tag Developer Guide — property tag, Attributes

Several lines of the page data show the attributes at work. The action’s markup property is <b>Dune</b> & "more":

Source: Tag Developer Guide — property tag, Examples

The default escaping is the first line of defence against cross-site scripting: the markup of the property is shown as text. escapeHtml="false" writes it raw and must be reserved for values that the application itself produced as markup. default replaces a null (a property that returns null, or one that does not exist, as P3 shows); an empty string is a value and is not replaced. A property tag with no value prints the top of the stack, which outside any loop is the action, hence P8, and an object that has no toString() of its own prints the class name and a hash code (P11). The Getting Started tutorial recommends overriding toString() of the model classes for this reason; property converts numbers, booleans and dates to strings by itself (the count, balance and featured properties printed 4, 1234.5 and true; a Date printed 9/13/65, the short date format of the locale, not a format of your choice, which is what s:date is for).

Source: Getting Started — Using Tags, Struts property tag

The three extra escapes stack on top of the default escapeHtml="true", which makes the combined output surprising; switch the HTML escape off when one of the others is the one needed (page data, lines P2 and PE1):

Source: Tag Developer Guide — property tag, Attributes (escape attributes)

The last line is the double escape: HTML escaping and then XML escaping turns < into <. Each escape is for a different context: escapeHtml for HTML text, escapeJavaScript for a value inside a JavaScript string (and the quotes and the slash are then backslash-escaped), escapeCsv for a CSV column (the value is quoted and a quote is doubled). Pick one, set the others off, and never write a property inside a <script> block with escapeHtml alone.

set assigns a value to a variable in a scope. It is the tag for a complex expression that a page uses several times: the expression is evaluated once and the rest of the page reads the variable, which is both faster and more readable.

Source: Tag Developer Guide — set tag, Attributes

Source: Tag Developer Guide — set tag, Examples

With a body, the body’s text (with the tags it contains evaluated) is the value (S2), and its leading and trailing whitespace is trimmed unless trimBody="false" (S3). Where the variable can be read depends on the scope, and the visibility differs for each way of reading it. The table summarises the observation of the page scope, which reads one variable of each kind with #name, #attr.name, #request.name and the JSP EL implicit objects pageScope, requestScope and ${name}:

Source: Tag Developer Guide — set tag, Description (the scopes)

The var of the other tags that have one (iterator, bean, url, text, date, number, action) is stored in the context map only and is read with #name (${name} also works through the request wrapper, as the loops with ${b2.title} in the JSTL section show). The Struts docs of the url tag add that, with var, the generated URL is placed in the request scope in addition to the action scope, and that a text tag with var writes nothing to the page.

push pushes a value onto the value stack for the duration of its body, so the properties of that object become the bare names inside it; it is the tag form of "work with this object". It has one required attribute, value.

Source: Tag Developer Guide — push tag, Examples

Inside the body title and author are properties of the pushed Book, top is that book and [1] is the stack without it, so [1].filter reads the action’s property. The nested push of PU2 shows the order of the stack: the inner element is on top, and [1].title reads the outer book. The guide’s examples use [1].top and top.property the same way to explain what each param of a bean sees. push is a convenience: a loop over one element is rarely needed in a page, and a model object is better exposed by ModelDriven (see ModelDriven, Preparable & CRUD) than pushed in the view.

bean instantiates a class that conforms to the JavaBeans specification, sets properties through nested param tags and pushes the bean on the stack for the body; with var it is also stored in the context, for later use. The class needs a public no-argument constructor and setters for the parameters, and, as for every object that OGNL touches, its package must be allowlisted: with a helper class in a package that was not (org.example.other.Helper), the tag created the object but its param setter and its getter were refused (is not allowlisted in the log) and the properties printed nothing. The attributes are name (required, the class name) and var.

Source: Tag Developer Guide — bean tag, Examples

Inside the body the bean is on top of the stack (name and city read its properties); outside, the stack is popped (the third value of BE1 is empty) and the var is the way back (#reader.name). The bean tag is a view-side object factory and it creates objects in the view that no action tests; use it for a helper such as a formatter or a counter, not for domain objects. A class that cannot be loaded is a silent failure: with name="org.example.bookshelf.NoSuch" the log had a ClassNotFoundException, the tag wrote nothing, and every expression after it on the page, even <s:property value="filter"/>, printed nothing (page bd), because the failed bean was left on the stack. A page that suddenly goes blank after a bean tag has a mistyped class name.

The param tag parameterises the tag that contains it: bean, include, url, a, text, action, append, merge and component are the tags that read it. It has name, value and suppressEmptyParameters. The guide stresses a difference between the two ways to give a value, which is rule 1 versus rule 2 in a new place:

Source: Tag Developer Guide — param tag, Description (WW-808)

The second form is the one that catches people out. value is an expression, blue is not a property, so the value is null; to pass the text it must be a literal, value="'blue'", or the body form. On the example page:

Source: Tag Developer Guide — param tag, Examples

The empty first value is null from the unquoted Lima. The same mistake appears in the FAQ of the guide about locale links (<s:param name="request_locale" value="en" />), where the quotes are missing. suppressEmptyParameters leaves an empty parameter out of the URL, see the url tag below.

action executes an action from within a view, and optionally renders its result in place: a way to compose a page from the output of several actions (a "portlet" of the shelf’s statistics on every page). Its attributes are name (required, the action name without extension), namespace (default: the namespace of the page), executeResult (default false), var, flush (default true), ignoreContextParams (default false, so the request parameters of the page are passed to the inner action) and rethrowException (default false). Nested param tags give parameters to the action.

Source: Tag Developer Guide — action tag, Examples

AC1 runs the action and reads its properties through the var; AC2 runs it and writes the result (the JSP stats.jsp) into the page; AC4 confirms the guide’s "Placement in context" rule, the action is published to the context only when the whole tag has finished, so inside the body #st4 is still null and outside it is not; AC8 shows a method call that works.

Source: Tag Developer Guide — action tag, Placement in context

Three behaviours of this tag differ from what the guide’s text implies:

Source: Tag Developer Guide — Struts Tags, FAQs (the action tag questions)

The action tag is a convenience with a cost: it executes a whole request cycle inside the page, so a page with ten of them runs ten action stacks. For a reusable fragment of a page a JSP include or a tag file is lighter (see the include tag below, and the Part I page Tag Files & Layouts).

text renders an internationalised message from a resource bundle, i18n puts another bundle on the stack for its body. The lookup order of the bundles and the locale selection are the subject of the Localization and i18n page, which also describes the key attribute of the form tags; this section is the tag side. text has name (required, the key), var and the four escape flags (all false by default, which differs from property: messages are not HTML-escaped).

Source: Tag Developer Guide — text tag, Examples

Source: Tag Developer Guide — i18n tag, Examples

Nested param tags fill the {0}, {1} placeholders of the MessageFormat pattern, a missing key prints the key, or the body when the tag has one, and a text with a var writes nothing and stores the text. The text is written without HTML escaping (add escapeHtml="true" if a bundle can contain markup you did not write). Three variations are different from the guide’s text:

date formats a Date (or java.time type) that is on the stack, in one of three ways: a format pattern, the nice relative form ("in 2 hours, 14 minutes"), or, with neither, the struts.date.format key of the bundles and finally the DateFormat.MEDIUM format of the locale. name (required) is the date expression, format, nice (default false), timezone and var are optional. If the value is missing from the stack the tag writes nothing.

Source: Tag Developer Guide — date tag, Examples

nice="true" produces the relative text with the struts.date.format.past, future, seconds, minutes, hours, days and years keys ({0} ago, in {0} and the choice patterns of the table in the guide), which are the keys to override in a bundle to translate it; the DT2 output changes with the day it is requested. The formatter is selected by the constant struts.date.formatter (default dateTimeFormatter, the java.time formatter; simpleDateFormatter selects the legacy one), and the patterns of the two differ slightly in letters, so a pattern that worked with SimpleDateFormat needs a check when the formatter is changed. The Localization and i18n page has the traps of a date pattern placed in a bundle (a MessageFormat passes over it first and swallows a single quote).

Source: Tag Developer Guide — date tag, Description

The number tag formats a number. It is in the 7.4.0 tag library descriptor and the org.apache.struts2.components.Number class, and it is not in the Tag Reference’s list of generic tags or on a page of its own (the address tag-developers/number-tag.html answers 404), so the TLD is the documentation. Its attributes are name (required, the number expression), type (currency, integer, number or percent, default number), currency (a currency code), groupingUsed, minimumFractionDigits, maximumFractionDigits, minimumIntegerDigits, maximumIntegerDigits, parseIntegerOnly, roundingMode (ceiling, down, floor, half-down, half-even, half-up, unnecessary, up) and var.

Source: Struts 7.4.0 — struts2-core-7.4.0.jar (META-INF/struts-tags.tld)

The formatting is locale-aware (en_US here); the integer type truncates by the RoundingMode of the format (1,234 from 1234.5 with the default half-even rule), while roundingMode="half-up" with maximumFractionDigits="0" printed 1,235.

include writes the output of a servlet or a JSP page into the page; value (required) is the path. Parameters are nested param tags and become request parameters of the included resource.

Source: Tag Developer Guide — include tag, Example

Parameters are read in the included page with ${param.title}, as the guide explains in "How to access parameters" (and its s:set var=... scope="page" examples copy them into the OGNL world): they are not properties on the stack and <s:property value="#attr.title"/> is empty. The guide says no value stack is created for the included page, so that s:property cannot read the parameters; on 7.4.0 the page still sees the request’s value stack (filter of the action printed all inside the included JSP, which is the same request), so the sentence is about the parameters, not about the stack. Compare with the standard jsp:include and c:import of the Part I page Includes, Forwards & Page Composition, which have the same request but not the OGNL view; a tag file is the better unit of reuse when the fragment has parameters of its own.

Source: Tag Developer Guide — include tag, How to access parameters

url creates a URL, a creates an HTML <a> with the same attributes. They know the action mapping: action (a name, with optional namespace and method) is turned into the right path with the context path and the extension, and the parameters are URL-encoded.

Source: Tag Developer Guide — url tag, Attributes

The page data (lines UR1 to UR8, requested with a cookie jar, so no ;jsessionid= is appended) prints:

Source: Tag Developer Guide — url tag, Examples

What the outputs teach:

Source: Tag Developer Guide — a tag, Usage

The a tag takes the attributes of url (A1 and A2), an explicit href (taken literally, with no context path, A1) and the HTML ones: id, cssClass, cssStyle, title, the on... events and any dynamic attribute (data-role, A4). The guide’s recommendation is to build a URL with several parameters in a s:url with a var and give the variable as href="%{#du}" (A2), which keeps the parameters readable. The Getting Started tutorial introduces the tag the simple way (a plain HTML a with the URL of an s:url inside the href):

Source: Getting Started — Using Tags, Struts url Tag

The second link reads the variable with the JSP EL ${helloLink} because url with var stores the URL in the request scope too. The tutorial notes that the query-string parameter is URL-encoded (Bruce+Phillips).

debug prints the contents of the value stack and the context, but only if struts.devMode is on; otherwise it writes nothing. On the example WAR in production mode the output of <s:debug/> was empty (page data, line DB1); a second build of the same WAR with struts.devMode=true printed a [Debug] link, a hidden div and a "Struts ValueStack Debug" table with the stack contents and the property names, values and classes of the action. The script that toggles the div carries a CSP nonce.

Source: Tag Developer Guide — debug tag

The tag shows the stack exactly as OGNL sees it, which is the quickest way to find out why an expression prints nothing; it must never be left on a deployed page, because the table lists every property of the action. The struts.devMode constant is documented on the Configuration: struts.xml & Constants page of this section.

script writes a <script> element and link writes a <link> element; both automatically add a nonce attribute when one is available, and are meant to be used with Struts' CSP interceptor. In Struts 7.4.0 the interceptor csp is part of the defaultStack (the stack trace of an error page lists CspInterceptor between i18n and prepare), so the page below, with no configuration at all, got a nonce, and the response had the header:

Source: Tag Developer Guide — script tag, Description

The default mode of the interceptor is report only, so the browser reports violations and does not block; the constants struts.csp.nonce.source (session, the default, or request) and struts.csp.report.maxSize (8192) are in default.properties (since 7.4.0 the older name struts.csp.nonceSource is deprecated), and the interceptor’s enforcingMode parameter switches to blocking. The page Security Headers: CSP, COOP, COEP & Fetch Metadata has the complete treatment of the CSP, Fetch Metadata and COOP/COEP interceptors.

Source: Tag Developer Guide — script tag, Examples

Source: Tag Developer Guide — link tag, Example

The attributes of script are the HTML ones (src, async, defer, type, nomodule, integrity, crossorigin, referrerpolicy, charset) plus id and dynamic attributes; those of link are href, rel, type, media, as, crossorigin, hreflang, referrerpolicy, sizes and the dynamic ones. The page notes that both inherit all the fields of the Component class, so some attributes the TLD lists (theme, template) have no effect on them. Two details in the output: the s:property inside the script body is expanded and escaped for HTML (a title with a quote would show as ", so a value for JavaScript needs escapeJavaScript="true" and escapeHtml="false"), and the element is written with its body on separate lines. The nonce is the same for every element of a page and is new for every request: three requests with the same session cookie printed three different nonces. With the default source session it is generated on each request and stored in the session attribute nonce (only for a session that already exists), with request in a request attribute.

webjar (since Struts 7.3.0) resolves a version-less WebJar path to a servable URL. A WebJar packages client-side libraries as a JAR that has its assets under META-INF/resources/webjars/<name>/<version>/; with the library on the class path as a Maven dependency, the tag writes the URL with the version that is present, so the page never repeats it and a dependency upgrade needs no change in the templates. Struts serves the assets under /static/webjars/** (the constant struts.ui.staticContentPath and the master switch struts.webjars.enabled, default true, an optional struts.webjars.allowlist of names), and resolves the version with webjars-locator-lite, which struts2-core bundles.

Source: Tag Developer Guide — webjar tag, Examples

Source: Core Developer Guide — Static Content, WebJars support

An unknown WebJar and a path with .. both produced an empty string (the page of the Core Developer Guide says unresolved, traversal and allowlist-blocked requests all fail closed: a 404 when serving and empty output when building URLs). The tag has the attributes path (required) and var, and composes with script, link and a raw <link> or <script>, as in the listing above.

compress (since Struts 7.2.0) removes the whitespace between the tags of its body while keeping the content, to reduce the size of generated HTML. It is enabled globally by struts.tag.compress.enabled (default true) and is switched off automatically in development mode so that the output stays readable; force="true" overrides that. The body size is limited by struts.tag.compress.maxSize (default 10485760, 10 MB, content above it is skipped without compression) and the log lines show at most struts.tag.compress.log.maxLength (200) characters of the body, so sensitive text is not written to the log.

Source: Tag Developer Guide — compress tag, Examples

Whitespace between tags is removed and whitespace inside text and inside <pre> is kept, so the tag does not change what a browser renders. In the devMode build the first block was left alone and the second, with force="true", was compressed. The documentation lists the safeguards: bodies above the size limit are left as they are, the regular expressions have a ReDoS guard with a hard 50 MB limit and the log text is truncated. The saving is small for pages that are served compressed by the container or a proxy; the tag is for pages generated with much indentation.

Source: Tag Developer Guide — compress tag, Related Configuration