<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
        <meta charset="utf-8">
        <title>Apache Wicket 9.0.0-M5 released | Apache Wicket</title>
        <meta name="viewport" content="width=device-width, initial-scale=1" />

        <link rel="shortcut icon" href="/favicon.ico" type="image/vnd.microsoft.icon" />
        <link rel="stylesheet" href="/css/style.css" type="text/css" media="screen" />
        <link href="//maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />

		<script src="//code.jquery.com/jquery-1.11.3.min.js"></script>

    </head>

    <body class="">
        <div class="header default">
    <div class="l-menu-container">
<nav class="mainmenu">
    <ul>
		<!-- /start/quickstart.html || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/start/quickstart.html">Quick Start</a></li>
		<!-- /start/download.html || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/start/download.html">Download</a></li>
		<!-- /learn || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/learn">Documentation</a></li>
		<!-- /help || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/help">Support</a></li>
		<!-- /contribute || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/contribute">Contribute</a></li>
		<!-- /community || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/community">Community</a></li>
		<!-- /apache || /news/2020/04/06/wicket-9.0.0-M5-released.html -->
    	<li class=""><a href="/apache">Apache</a></li>
    </ul>
</nav>
        <div class="logo">
    <a href="/"><img src="/img/logo-apachewicket.svg" alt="Apache Wicket"></a>
</div>
    </div>
</div>
<main>
    <div class="l-container">
        <header class="l-full preamble">
            <h1>Apache Wicket 9.0.0-M5 released</h1>
        </header>
        <section class="left">
            <div class="l-full">
    <p class="meta">06 Apr 2020</p>
    <p>The Apache Wicket PMC is proud to announce Apache Wicket 9.0.0-M5!</p>
<p>Apache Wicket is an open source Java component oriented web application
framework that powers thousands of web applications and web sites for
governments, stores, universities, cities, banks, email providers, and
more. You can find more about Apache Wicket at https://wicket.apache.org</p>
<p>This release marks another minor release of Wicket 9. We
use semantic versioning for the development of Wicket, and as such no
API breaks are present breaks are present in this release compared to
9.0.0.</p>
<h2 id="new-and-noteworthy">New and noteworthy</h2>
<p>With this milestone Wicket introduces support for content security policy (CSP) which
is active by default and prevents inline JavaScript and CSS code from been executed.
For more details about CSP support see Wicket 9 migration guide linked below.</p>
<h2 id="using-this-release">Using this release</h2>
<p>With Apache Maven update your dependency to (and don’t forget to
update any other dependencies on Wicket projects to the same version):</p>
<figure class="highlight"><pre><code class="language-xml" data-lang="xml"><span class="nt">&lt;dependency&gt;</span>
    <span class="nt">&lt;groupId&gt;</span>org.apache.wicket<span class="nt">&lt;/groupId&gt;</span>
    <span class="nt">&lt;artifactId&gt;</span>wicket-core<span class="nt">&lt;/artifactId&gt;</span>
    <span class="nt">&lt;version&gt;</span>9.0.0-M5<span class="nt">&lt;/version&gt;</span>
<span class="nt">&lt;/dependency&gt;</span></code></pre></figure>
<p>Or download and build the distribution yourself, or use our
convenience binary package you can find here:</p>
<ul>
  <li>Download: http://wicket.apache.org/start/wicket-9.x.html#manually</li>
</ul>
<!--more-->
<h2 id="upgrading-from-earlier-versions">Upgrading from earlier versions</h2>
<p>If you upgrade from 9.y.z this release is a drop in replacement. If
you come from a version prior to 9.0.0, please read our Wicket 9
migration guide found at</p>
<ul>
  <li>http://s.apache.org/wicket9migrate</li>
</ul>
<p>Have fun!</p>
<p>— The Wicket team</p>
<p>========================================================================</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>The signatures for the source release artefacts:
</code></pre></div></div>
<p>Signature for apache-wicket-9.0.0-M5.zip:</p>
<div class="highlight"><pre>
    -----BEGIN PGP SIGNATURE-----
iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAl6FsXoACgkQh48B+qjT
VuEZiA//fgy42gNrnUBO6Cbs6ZvJwzMLURlVuD/mrHZx5iLgnr7p9qgJzEZSfdF/
U0JPztMq6/crgi+aXPCjxzKdnGNlu665g3Xxyc3dr+N8psoWptGsBREBTtynQU2n
Pu9ir1THAE9qdr4MbqRZbH5wQGklPnLTfoTV6BS0HK4mmPCblK7eYBZlz7QnbOAL
MwuShMRLZ0phKZ3rwXFSJcWoZGyx6cmHPjs04VJkCdbtcOwBMNIzoU5CgbShvVt9
eXobPkOniJ2Ijr/B1ROVMrFOC7uduJilFj2dk+icZZgrO6177pDO57bX1It3Ts3J
UbOJKdtBIHMD9XNe1ANPodMMwxA5Q0hUpjsehPqZVFgYpEfHxyPENVkjlabqHOt/
8ySL79MfOGzckNPUrR16HS0RTrBjsSrLnif5bHcaFyIg6UL0RrdOlJaI6CU01V/Y
zPBtI3Dm1R4acUCrU08nScoeR+uS7F6oTSQD2X+pEsBG6euX0q1fV4HhtVQSRIFU
pSrSAavkQjUL0tl6ik8HeGOlMFXT66U0Q6gnI/KmxcHZAroWU6j2qvYOcfawIEkw
qZfgo0ZnJN4/VxAl51+On64LkaxpCCBCh8+yZ2DW7efcKDWElXpC1IOhvuFTYDgt
WouuIOaT0Hdura6SBdp6WYwwLzUP/nk1s6A6EfYtpanlWxblzLE=
=062g
-----END PGP SIGNATURE-----
</pre></div>
<p>Signature for apache-wicket-9.0.0-M5.tar.gz:</p>
<div class="highlight"><pre>
    -----BEGIN PGP SIGNATURE-----
iQIzBAABCgAdFiEE0a6YZHC1pJw+aieyh48B+qjTVuEFAl6FsXoACgkQh48B+qjT
VuHV3Q//QlqtUlnAtEn2KN0XdinerjOrG8Ny9M7/apRqVjij57Ye+LrIPWnd0+Bj
WqTVx/4nuJ/HcC+e1fwrSkekSZW0n2ecO9GKo/k7KyDRxsbKnPyCP3JjqJfhDf/R
6seFXrGJWLfQo844kuLJz5Ug3wjEqiOQk2HmgXTQmUdcGlTsXAioSkHttLNQjLZC
bF2LD3ZqwJw0R/7o1t4WAi1h7iriGKGrehgk6k/9h8DKTvKGduEDfWtSPu4R8Ogr
/i71FQt5w+87wKLP/viUHkIg0+KAHGmVu9Qz1AYHLc20oJv63N273ZeiIRuFWmCj
jw+1WfJUQvxFxfV1CxNCl/IBGPjD4FS3sygg867uEgShNFVNzVA+vplEDRl3i9e9
GaMgQsfVBi8eZzoGtgga0cQhgOU4hvOwv8lHNaC6XHYV18/p6j9P1tthtPsL2Krk
AzFfJ3Ym/gRf2thKop4iMn2xU16bu1D33zSPJ3C0kGlWqHQFw5+gBLNLOthv3YyV
LZGqSmsPg2sNcWDPqaUGQAVGNXmogjpbw6X9aEx2VtXfLQItRMNJq6lpoCtPQryK
UhgTTb4z4wE1dUDhyuIAVgKXgtUdKg7Q8oxmIfV4zl4OdRzBCYuHJ8md0Q7Tg0PC
BiSUhll+1igfRg1tUYItJ7TtV6uqdRZIg+YMsZ98ZKp24xcy1rI=
=GdAn
-----END PGP SIGNATURE-----
</pre></div>
<p>========================================================================</p>
<h3 id="this-release">This Release</h3>
<h4 id="changelog-for-900-m5">CHANGELOG for 9.0.0-M5:</h4>
<h5 id="bug">Bug</h5>
<ul>
  <li>[WICKET-6715] - FileUpload class should not  implement IClusterable</li>
  <li>[WICKET-6745] - CSP: inline JS in server and client time response filters</li>
  <li>[WICKET-6746] - HttpsMapper cannot deal with resources over websockets</li>
  <li>[WICKET-6752] - Some dependencies contain CVEs</li>
  <li>[WICKET-6753] - res/modal.js using aria-labelledby where it should be using aria-label</li>
  <li>[WICKET-6754] - Iteration stops with nested containers</li>
  <li>[WICKET-6755] - MockServletContext does not decode real path</li>
  <li>[WICKET-6756] - Avoid URL.getFile() when actually expecting paths.</li>
  <li>[WICKET-6757] - Avoid URL.getFile during mime type detection.</li>
  <li>[WICKET-6758] - NPE in AbstractWebSocketProcessor after session times out</li>
</ul>
<h5 id="new-feature">New Feature</h5>
<ul>
  <li>[WICKET-6727] - Configurable CSP</li>
  <li>[WICKET-6729] - allow adding IHeaderResponseDecorator without replacing all others</li>
  <li>[WICKET-6730] - Global access to secure random data</li>
</ul>
<h5 id="improvement">Improvement</h5>
<ul>
  <li>[WICKET-6724] - CSP: Inline Javascript in AjaxLink</li>
  <li>[WICKET-6725] - CSP: display:none in Component.renderPlaceholderTag</li>
  <li>[WICKET-6726] - CSP: inline styling and js in Form submitbutton handling</li>
  <li>[WICKET-6731] - CSP: inline JS in SubmitLink</li>
  <li>[WICKET-6732] - CSP: inline JS in Link and ExternalLink</li>
  <li>[WICKET-6733] - CSP: enable by default</li>
  <li>[WICKET-6735] - CSP: inline styling in FormComponentFeedbackBorder/Indicator</li>
  <li>[WICKET-6736] - CSP: Inline styling in BrowserInfoForm</li>
  <li>[WICKET-6737] - CSP: violations in examples</li>
  <li>[WICKET-6738] - CSP: inline styling in UploadProgressBar</li>
  <li>[WICKET-6739] - CSP: inline JS in Palette</li>
  <li>[WICKET-6740] - CSP: inline JS in Button</li>
  <li>[WICKET-6741] - CSP: inline JS in FormComponentUpdatingBehavior</li>
  <li>[WICKET-6749] - CSP: Inline styling in ExceptionErrorPage.html</li>
  <li>[WICKET-6759] - Support disabling error notification for websockets</li>
  <li>[WICKET-6760] - Nested Form placeholder should preserve tag name</li>
  <li>[WICKET-6761] - Support multiple connections to the same websocket resource from a single session</li>
  <li>[WICKET-6762] - Support manual initialization of websocket connections</li>
</ul>
<h5 id="tasks">Tasks</h5>
<ul>
  <li>[WICKET-6687] - Cleanup the code from attribute inline styles and attribute inline scripts</li>
  <li>[WICKET-6747] - Document CSP in user guide and migration guide</li>
  <li>[WICKET-6751] - Support creating custom page access synchronization strategies</li>
</ul>
</div>
        </section>
    </div>
</main>
        <footer class="l-container">
            <div class="l-full">
   	<img src="/img/asf_logo_url.svg" style="height:90px; float:left; margin-right:10px;">
    <div style="margin-top:12px;">Copyright © 2020 — The Apache Software Foundation. Apache Wicket, Wicket, Apache, the Apache feather logo, and the Apache Wicket project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.</div>
</div>
        </footer>
    </body>

</html>
