---
layout: default
title: Announcements 2010
---

<h1>Announcements - 2010</h1>

<p class="pull-right">
  Skip to: <a href="announce-2009.html">Announcements - 2009</a>
</p>

<h4 id="a20101220">20 December 2010 - Struts 2.2.1.1 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 2.2.1.1 is
  available as a "General Availability" release. The GA designation is our
  highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for creating
  enterprise-ready Java web applications. The framework is designed to
  streamline the full development cycle, from building, to deploying, to
  maintaining applications over time.
</p>
<p>
  This release includes one important security fix regarding Dynamic Method
  Invocation in the REST Plugin. In the previous versions DMI wasn't under control
  in the REST Plugin and even setting struts.enable.DynamicMethodInvocation to false
  didn't block DMI in the REST Plugin.
</p>
<p>
  All developers are strongly advised to update existing Struts 2 applications
  to Struts 2.2.1.1.
</p>
<p>
  Struts 2.2.1.1 is available in a full distribution,
  or as separate library, source, example and documentation
  distributions, from the
  <a href="http://struts.apache.org/download.cgi#struts2211">releases page</a>.
  The release is also available through the central Maven repository under Group ID
  "org.apache.struts". The
  <a href="http://struts.apache.org/2.2.1.1/docs/version-notes-2211.html">release notes</a>
  are available online.
</p>
<p>
  The 2.2.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API 2.4,
  JSP API 2.0, and Java 5.
</p>
<p>
  Should any issues arise with your use of any version of the Struts
  framework, please post your comments to the user list, and, if
  appropriate, file a tracking ticket.
</p>

<h4 id="a20100816">16 August 2010 - Struts 2.2.1 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 2.2.1 is
  available as a "General Availability" release. The GA designation is our
  highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for creating
  enterprise-ready Java web applications. The framework is designed to
  streamline the full development cycle, from building, to deploying, to
  maintaining applications over time.
</p>
<p>
  This release includes a number of new features and bug fixes since the
  2.1.8.1 GA release, including important security fixes regarding remote
  server context manipulation by injecting OGNL expressions in request parameters.
  For more information about the exploits, see the corresponding
  security bulletins <a href="http://struts.apache.org/2.2.1/docs/s2-005.html">S2-005</a>.
</p>
<p>
  All developers are strongly advised to update existing Struts 2 applications
  to Struts 2.2.1.
</p>
<p>
  Struts 2.2.1 is available in a full distribution,
  or as separate library, source, example and documentation
  distributions, from the
  <a href="http://struts.apache.org/download.cgi#struts221">releases page</a>.
  The release is also available through the central Maven repository under Group ID
  "org.apache.struts". The
  <a href="http://struts.apache.org/2.2.1/docs/version-notes-221.html">release notes</a>
  are available online.
</p>
<p>
  The 2.2.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API 2.4,
  JSP API 2.0, and Java 5.
</p>
<p>
  Should any issues arise with your use of any version of the Struts
  framework, please post your comments to the user list, and, if
  appropriate, file a tracking ticket.
</p>

<p class="pull-right">
  Skip to: <a href="announce-2009.html">Announcements - 2009</a>
</p>

<p class="pull-left">
  <strong>Next:</strong>
  <a href="kickstart.html">Kickstart FAQ</a>
</p>
