You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by ad...@apache.org on 2020/06/25 15:22:15 UTC
[wicket-site] 17/18: Added an "headline" announce
This is an automated email from the ASF dual-hosted git repository.
adelbene pushed a commit to branch wicket-9
in repository https://gitbox.apache.org/repos/asf/wicket-site.git
commit 9b44d35927e6000f3210f3f56f4f91d6af1e1069
Author: Andrea Del Bene <ad...@apache.org>
AuthorDate: Thu Jun 25 12:55:45 2020 +0200
Added an "headline" announce
---
...75d113ab440946a19dcbc70e15f550e6f322bf454ffd09} | 10 +-
...fb05384da8c1846d919fc6cc980ecca2d6de864c01fdbc7 | 273 --------------------
...8b7f3ceeefa14ddce67a9c781a16d83f103995040e2b3cc | 282 ---------------------
...033768ddc91749cc86b59d6e39bea83e21073f1e73aa46e | 207 ---------------
...ef17652f39413b7b9359e581f6691b1a084955b2441633a | 207 ---------------
...a45ce97215b673152943ad96489334aeafa84719f23a6d9 | 273 --------------------
...20efc0d2eeeaf0a817e65dc20928f1a27015535f40d6a37 | 282 ---------------------
...886915876f552966a4a3616082eecfe6a5c467511dcab75 | 280 --------------------
...8de63f1f464b64b33dd926dd5b1b5a9e70ae8805df13e31 | 273 --------------------
...e9e20e43eb58af9f15d9791d0a5a9e8dfbf12b80daf9060 | 280 --------------------
...bab1fcaf54f05ab5b6efa83098e0f92539f2094a0d31a3} | 8 +-
...d0984f230f8676ce4c9667cd3ab734028e27c8b0d24ef6} | 18 +-
...2f8332fc7b25ccc6a38ae07384c68211ca03b416b2a5992 | 280 --------------------
...8a71c5e0b8d74aaaed602e1bd8ac0c420fca129c82374e} | 18 +-
...1807c5ad099388ddc213bb07fc64c604a3991bde4d20f3a | 208 ---------------
...869cbd900082064dad149ff6800fdd697bd66cdf91227cc | 282 ---------------------
...0691b4518708701acb68b13012f0b178ce85ec348ef167f | 281 --------------------
...b9559fec19b304b38462ca9bd9fc09e2d751f0dc8524403 | 281 --------------------
...ab231bf4a95f28d338e375c7c6ad44e72ef5c236fe6144} | 8 +-
...a77c316d63ee61e632476f0a6c92329ab8237f5c8d5c80a | 273 --------------------
...16deb561ca5be2db9a73c88e0a68b3d9a4cef5d7b2d7160 | 278 --------------------
...fee440448e60f4c62f142ee42c9b52e2153e5b645071e65 | 280 --------------------
...a31d4c28bf1ec0b78d9351c49c9d23648bea4bcf9cad80} | 8 +-
...2267e2914f751be1f3bd36e87977adf6a1613fb854253bc | 211 ---------------
...b0b984b777cb7bc8a10b3dfcda6b1c960858494141a26c6 | 280 --------------------
...fcb14d9de30874d898fc8f95e7806ccbdda4c8a8a3d6f6d | 211 ---------------
...4c3a852b7aeabf534464eba7dc6599f0aecf51f94993cab | 273 --------------------
_sass/taiga/_base.scss | 6 +
content/atom.xml | 2 +-
content/css/style.css | 2 +
content/css/style.css.map | 4 +-
content/index.html | 12 +-
index.md | 12 +-
33 files changed, 50 insertions(+), 5553 deletions(-)
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/b84e40c321ee7bc887a817e02108962975194f558911b08de278bac64bdb47 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/00/9fc6733170c1998e75d113ab440946a19dcbc70e15f550e6f322bf454ffd09
similarity index 96%
rename from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/b84e40c321ee7bc887a817e02108962975194f558911b08de278bac64bdb47
rename to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/00/9fc6733170c1998e75d113ab440946a19dcbc70e15f550e6f322bf454ffd09
index 207c20d..4b13be4 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/b84e40c321ee7bc887a817e02108962975194f558911b08de278bac64bdb47
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/00/9fc6733170c1998e75d113ab440946a19dcbc70e15f550e6f322bf454ffd09
@@ -1,12 +1,10 @@
-I"P)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
+I"D)<div class="l-full l-first preamble">
+ <h1 id="introduction" class="announce">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<div>
<img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
</div>
<p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
</div>
@@ -45,7 +43,7 @@
You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
</p>
<p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
+ Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank">documentation</a> for more information.
</p>
</div>
</div>
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/d26df7f93807306fb05384da8c1846d919fc6cc980ecca2d6de864c01fdbc7 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/d26df7f93807306fb05384da8c1846d919fc6cc980ecca2d6de864c01fdbc7
deleted file mode 100644
index 38c978f..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/06/d26df7f93807306fb05384da8c1846d919fc6cc980ecca2d6de864c01fdbc7
+++ /dev/null
@@ -1,273 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the [OpenJDK Quality Outreach](https://wiki.openjdk.java.net/display/quality/Quality+Outreach), an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0b/29c0ebb44289ea18b7f3ceeefa14ddce67a9c781a16d83f103995040e2b3cc b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0b/29c0ebb44289ea18b7f3ceeefa14ddce67a9c781a16d83f103995040e2b3cc
deleted file mode 100644
index d1febad..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/0b/29c0ebb44289ea18b7f3ceeefa14ddce67a9c781a16d83f103995040e2b3cc
+++ /dev/null
@@ -1,282 +0,0 @@
-I"><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/11fa6d491d208b0033768ddc91749cc86b59d6e39bea83e21073f1e73aa46e b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/11fa6d491d208b0033768ddc91749cc86b59d6e39bea83e21073f1e73aa46e
deleted file mode 100644
index 5777161..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/22/11fa6d491d208b0033768ddc91749cc86b59d6e39bea83e21073f1e73aa46e
+++ /dev/null
@@ -1,207 +0,0 @@
-I"�(<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Protect your web apps with Content Security Policy (CSP)</h3>
- <p>
- As the number of security threats grows, it's crucial for web applications to adopt the latest security standards and countermeasures. CSP is a modern standard that allows applications to declare approved origins of content (such as Javascript, CSS, images, etc...) for the browser to load. Constructing a safe and at the same time complete CSP can be challenging.
- </p>
- <p>
- You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities. Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for fl [...]
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2e/b5d739e2eed7825ef17652f39413b7b9359e581f6691b1a084955b2441633a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2e/b5d739e2eed7825ef17652f39413b7b9359e581f6691b1a084955b2441633a
deleted file mode 100644
index a532bc4..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/2e/b5d739e2eed7825ef17652f39413b7b9359e581f6691b1a084955b2441633a
+++ /dev/null
@@ -1,207 +0,0 @@
-I"$)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Protect your web apps with Content Security Policy (CSP)</h3>
- <p>
- As the number of security threats grows, it's crucial for web applications to adopt the latest security standards and countermeasures. CSP is a modern standard that allows applications to declare approved origins of content (such as Javascript, CSS, images, etc...) for the browser to load. Constructing a safe and at the same time complete CSP can be challenging.
- </p>
- <p>
- You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities. Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for fl [...]
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/2024853a555c2bca45ce97215b673152943ad96489334aeafa84719f23a6d9 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/2024853a555c2bca45ce97215b673152943ad96489334aeafa84719f23a6d9
deleted file mode 100644
index c4604c8..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/40/2024853a555c2bca45ce97215b673152943ad96489334aeafa84719f23a6d9
+++ /dev/null
@@ -1,273 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/9facc961452690f20efc0d2eeeaf0a817e65dc20928f1a27015535f40d6a37 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/9facc961452690f20efc0d2eeeaf0a817e65dc20928f1a27015535f40d6a37
deleted file mode 100644
index 0694ead..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/48/9facc961452690f20efc0d2eeeaf0a817e65dc20928f1a27015535f40d6a37
+++ /dev/null
@@ -1,282 +0,0 @@
-I" ><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
- </div>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/0949844d4b53997886915876f552966a4a3616082eecfe6a5c467511dcab75 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/0949844d4b53997886915876f552966a4a3616082eecfe6a5c467511dcab75
deleted file mode 100644
index 290ea70..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/4e/0949844d4b53997886915876f552966a4a3616082eecfe6a5c467511dcab75
+++ /dev/null
@@ -1,280 +0,0 @@
-I"�=<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <p></p>
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/228cc4c91e3238f8de63f1f464b64b33dd926dd5b1b5a9e70ae8805df13e31 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/228cc4c91e3238f8de63f1f464b64b33dd926dd5b1b5a9e70ae8805df13e31
deleted file mode 100644
index 7cd7761..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/56/228cc4c91e3238f8de63f1f464b64b33dd926dd5b1b5a9e70ae8805df13e31
+++ /dev/null
@@ -1,273 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" _target="blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/9eea9275751f70de9e20e43eb58af9f15d9791d0a5a9e8dfbf12b80daf9060 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/9eea9275751f70de9e20e43eb58af9f15d9791d0a5a9e8dfbf12b80daf9060
deleted file mode 100644
index 79e42de..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/64/9eea9275751f70de9e20e43eb58af9f15d9791d0a5a9e8dfbf12b80daf9060
+++ /dev/null
@@ -1,280 +0,0 @@
-I"><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <p><img src="/img/logo.svg" alt="Apache Wicket" style="max-height: 200px;" /></p>
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/31e5ff4e88117daabab1fcaf54f05ab5b6efa83098e0f92539f2094a0d31a3
similarity index 98%
copy from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
copy to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/31e5ff4e88117daabab1fcaf54f05ab5b6efa83098e0f92539f2094a0d31a3
index 1cf5671..842965b 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/31e5ff4e88117daabab1fcaf54f05ab5b6efa83098e0f92539f2094a0d31a3
@@ -1,12 +1,10 @@
-I"C)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
+I"3)<div class="l-full l-first preamble">
+ <h1 id="introduction">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<div>
<img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
</div>
<p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
</div>
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/65/3f604fc35f5f979afb4444689ae521d4b8d9e7b4c792f93bf47e5839b1f417 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/58bb59055e9076fdd0984f230f8676ce4c9667cd3ab734028e27c8b0d24ef6
similarity index 95%
rename from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/65/3f604fc35f5f979afb4444689ae521d4b8d9e7b4c792f93bf47e5839b1f417
rename to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/58bb59055e9076fdd0984f230f8676ce4c9667cd3ab734028e27c8b0d24ef6
index cd26e43..8243aac 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/65/3f604fc35f5f979afb4444689ae521d4b8d9e7b4c792f93bf47e5839b1f417
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/68/58bb59055e9076fdd0984f230f8676ce4c9667cd3ab734028e27c8b0d24ef6
@@ -1,14 +1,12 @@
-I"P)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
+I"D)<div class="l-full l-first preamble">
+ <h1 id="introduction" class="announce">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
+ <div>
+ <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
+ </div>
</div>
<div class="l-first">
<div class="l-full">
@@ -45,7 +43,7 @@
You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
</p>
<p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
+ Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank">documentation</a> for more information.
</p>
</div>
</div>
@@ -66,7 +64,7 @@
When you migrate from a previous Wicket version to Wicket 9, a full list of changes and migrations is available at the following page:
</p>
<p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket9migrate</a>
+ <a href="https://s.apache.org/wicket9migrate">https://s.apache.org/wicket9migrate</a>
</p>
<p>
Please consult this migration guide when you are moving towards Wicket 9.
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6b/7371257bc07f6e12f8332fc7b25ccc6a38ae07384c68211ca03b416b2a5992 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6b/7371257bc07f6e12f8332fc7b25ccc6a38ae07384c68211ca03b416b2a5992
deleted file mode 100644
index 17161f5..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/6b/7371257bc07f6e12f8332fc7b25ccc6a38ae07384c68211ca03b416b2a5992
+++ /dev/null
@@ -1,280 +0,0 @@
-I"�=<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <p><img src="/img/logo.svg" alt="Apache Wicket" /></p>
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/dc96eabd93af8d60b9164164612db4cfe92f9a4e41c044e868a0bd000e3174 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/328c776b0cb34b648a71c5e0b8d74aaaed602e1bd8ac0c420fca129c82374e
similarity index 94%
rename from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/dc96eabd93af8d60b9164164612db4cfe92f9a4e41c044e868a0bd000e3174
rename to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/328c776b0cb34b648a71c5e0b8d74aaaed602e1bd8ac0c420fca129c82374e
index ffd5889..9b1d2b9 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/87/dc96eabd93af8d60b9164164612db4cfe92f9a4e41c044e868a0bd000e3174
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/93/328c776b0cb34b648a71c5e0b8d74aaaed602e1bd8ac0c420fca129c82374e
@@ -1,12 +1,10 @@
-I"P)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
+I"3)<div class="l-full l-first preamble">
+ <h1 id="introduction">"Announcing Apache Wicket 9: get into the modern Java world</h1>
<div>
<img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
</div>
<p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
</div>
@@ -45,7 +43,7 @@
You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
</p>
<p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
+ Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank">documentation</a> for more information.
</p>
</div>
</div>
@@ -61,15 +59,15 @@
</p>
</div>
<div class="l-half">
- <h3>Migrating to Wicket 8</h3>
+ <h3>Migrating to Wicket 9</h3>
<p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
+ When you migrate from a previous Wicket version to Wicket 9, a full list of changes and migrations is available at the following page:
</p>
<p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
+ <a href="https://s.apache.org/wicket9migrate">https://s.apache.org/wicket9migrate</a>
</p>
<p>
- Please consult this migration guide when you are moving towards Wicket 8.
+ Please consult this migration guide when you are moving towards Wicket 9.
</p>
</div>
</div>
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/e6ea79fc1fb1aa11807c5ad099388ddc213bb07fc64c604a3991bde4d20f3a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/e6ea79fc1fb1aa11807c5ad099388ddc213bb07fc64c604a3991bde4d20f3a
deleted file mode 100644
index 549cd49..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9c/e6ea79fc1fb1aa11807c5ad099388ddc213bb07fc64c604a3991bde4d20f3a
+++ /dev/null
@@ -1,208 +0,0 @@
-I"))<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Protect your web apps with Content Security Policy (CSP)</h3>
- <p>
- As the number of security threats grows, it's crucial for web applications to adopt the latest security standards and countermeasures. CSP is a modern standard that allows applications to declare approved origins of content (such as Javascript, CSS, images, etc...) for the browser to load. Constructing a safe and at the same time complete CSP can be challenging.
- You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
- </p>
- <p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9d/9db3a0191c1b9c5869cbd900082064dad149ff6800fdd697bd66cdf91227cc b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9d/9db3a0191c1b9c5869cbd900082064dad149ff6800fdd697bd66cdf91227cc
deleted file mode 100644
index 2710764..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/9d/9db3a0191c1b9c5869cbd900082064dad149ff6800fdd697bd66cdf91227cc
+++ /dev/null
@@ -1,282 +0,0 @@
-I"$><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/c286bb2cc287e590691b4518708701acb68b13012f0b178ce85ec348ef167f b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/c286bb2cc287e590691b4518708701acb68b13012f0b178ce85ec348ef167f
deleted file mode 100644
index 96cdc2a..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/a8/c286bb2cc287e590691b4518708701acb68b13012f0b178ce85ec348ef167f
+++ /dev/null
@@ -1,281 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/aa/e0078ad21c89b93b9559fec19b304b38462ca9bd9fc09e2d751f0dc8524403 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/aa/e0078ad21c89b93b9559fec19b304b38462ca9bd9fc09e2d751f0dc8524403
deleted file mode 100644
index 803b5a7..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/aa/e0078ad21c89b93b9559fec19b304b38462ca9bd9fc09e2d751f0dc8524403
+++ /dev/null
@@ -1,281 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/af/0976fc6498a97d29ab231bf4a95f28d338e375c7c6ad44e72ef5c236fe6144
similarity index 97%
copy from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
copy to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/af/0976fc6498a97d29ab231bf4a95f28d338e375c7c6ad44e72ef5c236fe6144
index 1cf5671..6848357 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/af/0976fc6498a97d29ab231bf4a95f28d338e375c7c6ad44e72ef5c236fe6144
@@ -1,12 +1,10 @@
-I"C)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
+I"Q)<div class="l-full l-first preamble">
+ <h1 id="introduction" class)="announce">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<div>
<img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
</div>
<p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
</div>
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b2/a799e3ef019639ea77c316d63ee61e632476f0a6c92329ab8237f5c8d5c80a b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b2/a799e3ef019639ea77c316d63ee61e632476f0a6c92329ab8237f5c8d5c80a
deleted file mode 100644
index 9fc2e50..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b2/a799e3ef019639ea77c316d63ee61e632476f0a6c92329ab8237f5c8d5c80a
+++ /dev/null
@@ -1,273 +0,0 @@
-I"�><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a src="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" _target="blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/5b83e3d42ca7d5d16deb561ca5be2db9a73c88e0a68b3d9a4cef5d7b2d7160 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/5b83e3d42ca7d5d16deb561ca5be2db9a73c88e0a68b3d9a4cef5d7b2d7160
deleted file mode 100644
index 9aa9843..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/b7/5b83e3d42ca7d5d16deb561ca5be2db9a73c88e0a68b3d9a4cef5d7b2d7160
+++ /dev/null
@@ -1,278 +0,0 @@
-I"-?<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the [OpenJDK Quality Outreach](https://wiki.openjdk.java.net/display/quality/Quality+Outreach), an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-one-third">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cc/44c2f6832d139c6fee440448e60f4c62f142ee42c9b52e2153e5b645071e65 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cc/44c2f6832d139c6fee440448e60f4c62f142ee42c9b52e2153e5b645071e65
deleted file mode 100644
index 9e480c4..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/cc/44c2f6832d139c6fee440448e60f4c62f142ee42c9b52e2153e5b645071e65
+++ /dev/null
@@ -1,280 +0,0 @@
-I"
><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/da/ede77bf791093e81a31d4c28bf1ec0b78d9351c49c9d23648bea4bcf9cad80
similarity index 98%
rename from .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
rename to .jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/da/ede77bf791093e81a31d4c28bf1ec0b78d9351c49c9d23648bea4bcf9cad80
index 1cf5671..c79c8a9 100644
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/97/76237beac3fabe2ab0324362267797dda3df30a56ce9d45f0c6ac0a925dc9b
+++ b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/da/ede77bf791093e81a31d4c28bf1ec0b78d9351c49c9d23648bea4bcf9cad80
@@ -1,12 +1,10 @@
-I"C)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
+I"2)<div class="l-full l-first preamble">
+ <h1 id="introduction">Announcing Apache Wicket 9: get into the modern Java world</h1>
<div>
<img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
</div>
<p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
</div>
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/7fefe2bc1f24a1d2267e2914f751be1f3bd36e87977adf6a1613fb854253bc b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/7fefe2bc1f24a1d2267e2914f751be1f3bd36e87977adf6a1613fb854253bc
deleted file mode 100644
index 3a61cb6..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/7fefe2bc1f24a1d2267e2914f751be1f3bd36e87977adf6a1613fb854253bc
+++ /dev/null
@@ -1,211 +0,0 @@
-I"A)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
- Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Protect your web apps with Content Security Policy (CSP)</h3>
- <p>
- As the number of security threats grows, it's crucial for web applications to adopt the latest security standards and countermeasures. CSP is a modern standard that allows applications to declare approved origins of content (such as Javascript, CSS, images, etc...) for the browser to load. Constructing a safe and at the same time complete CSP can be challenging.
- You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
- </p>
- <p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/e55b165d8ee9d0ab0b984b777cb7bc8a10b3dfcda6b1c960858494141a26c6 b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/e55b165d8ee9d0ab0b984b777cb7bc8a10b3dfcda6b1c960858494141a26c6
deleted file mode 100644
index efd5133..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f5/e55b165d8ee9d0ab0b984b777cb7bc8a10b3dfcda6b1c960858494141a26c6
+++ /dev/null
@@ -1,280 +0,0 @@
-I"><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <p><img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" /></p>
- <p>
- The Apache Wicket project announces the 8th major release of the open source Java web framework servicing websites and applications across the globe for over a decade. With this release Wicket embraces Java 8 idioms fully, allowing the use of lambda expressions in all the right places. With Wicket 8 you can write fewer, faster and more maintainable code.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>A Careful Application of Java 8</h3>
-
- <p>
- While previous versions of Wicket work well with Java 8 and beyond, the Wicket API was not optimized to make full use of Java 8 idioms. After careful consideration and trying many paths to adopt new ways of combining Java 8 and Wicket, we finally settled on the current API.
- </p>
- <p>
- Java 8’s new idioms and types have been applied throughout Wicket’s API. Learn more about the details below.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Java 8+ Required</h3>
- <p>
- Starting with Wicket 8 the minimum required version of Java is Java 8. All Wicket supplied projects have been upgraded to Java 8 and Wicket 8, and shortly all active community projects, such as Wicket Stuff, will follow suit.
- </p>
- <p>
- With the adoption of Java 8 we were able to provide support for Lambdas.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Servlet 3.1 Required</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
- <div class="l-one-third">
- <h3>Java Date/Time API</h3>
- <p>
- Wicket 8 provides out-of-the-box support for the new types for handling dates in Java 8. These can be converted, validated and bound to components.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/5c38a3ee8c9d6c6fcb14d9de30874d898fc8f95e7806ccbdda4c8a8a3d6f6d b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/5c38a3ee8c9d6c6fcb14d9de30874d898fc8f95e7806ccbdda4c8a8a3d6f6d
deleted file mode 100644
index 8bdc5fb..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/f7/5c38a3ee8c9d6c6fcb14d9de30874d898fc8f95e7806ccbdda4c8a8a3d6f6d
+++ /dev/null
@@ -1,211 +0,0 @@
-I"P)<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
- <p>
- Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the <a href="https://wiki.openjdk.java.net/display/quality/Quality+Outreach" target="_blank">OpenJDK Quality Outreach</a>, an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- Shortly after Java 9 was released, Oracle submitted Java EE to the Eclipse Foundation. As side effect of this owner change, the package name 'javax' had to be migrate to 'jakarta'. Wicket historically promoted decupling between Java EE APIs and application code, hence making much more easier the transition to the future Java Enterprise versions.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Protect your web apps with Content Security Policy (CSP)</h3>
- <p>
- As the number of security threats grows, it's crucial for web applications to adopt the latest security standards and countermeasures. CSP is a modern standard that allows applications to declare approved origins of content (such as Javascript, CSS, images, etc...) for the browser to load. Constructing a safe and at the same time complete CSP can be challenging.
- You either risk leaving holes in the defense of your application or you break certain functionality. Protecting against unwanted inline scripts is the most important target to attain. In CSP this is called 'unsafe-inline' and it's the most common cause of cross-site scripting vulnerabilities.
- </p>
- <p>
- Wicket 9 comes with full support for CSP and does not need any unsafe directives. Wicket will automatically add a nonce to every header contribution and whitelist this nonce. This allows for flexible loading of resources without the need of a complex CSP. Of course it is possible to modify and customize the CSP, add additional directives or disable it entirely. Lookup our <a href="http://wicket.apache.org/learn/#guide" target="_blank"">documentation</a> for more informat [...]
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>9.0.0-M5<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/9.0.0-M5">9.0.0-M5 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/9.0.0-M5/binaries">9.0.0-M5 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/d3a02a0ef53ae684c3a852b7aeabf534464eba7dc6599f0aecf51f94993cab b/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/d3a02a0ef53ae684c3a852b7aeabf534464eba7dc6599f0aecf51f94993cab
deleted file mode 100644
index 162bb6c..0000000
--- a/.jekyll-cache/Jekyll/Cache/Jekyll--Converters--Markdown/fa/d3a02a0ef53ae684c3a852b7aeabf534464eba7dc6599f0aecf51f94993cab
+++ /dev/null
@@ -1,273 +0,0 @@
-I"4><div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004. Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
- </p>
-</div>
-<div class="l-first">
- <div class="l-full">
- <h3>Bring the web into the modern Java era</h3>
- <p>
- The release of Java 9 has been a turning point in Java history which laid the foundation for the modern Java era. However, the magnitude of this change has discourage many developers from leaving the safe harbor rappresented by Java 8. With Wicket 9 we finally have a fundamental tool to move on and bring our web application into the new Java world.
- </p>
- <p>
- With this version Wicket has been completed revisited and improved to embrace new technologies like Java modularization and new library like JUnit 5.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>Stay up to date with Java release cycle</h3>
- <p>
- With Java releasing at a faster phase it's important to keep a library up to date with the lastest changes introduced in the platform and ensure it works with the latest Java release. Wicket does all of this by taking part to the [OpenJDK Quality Outreach](https://wiki.openjdk.java.net/display/quality/Quality+Outreach), an initiative aimed to test popular Open Source projects with both the latest OpenJDK release and the Early Access release.
- </p>
- </div>
- <div class="l-half">
- <h3> Be ready for the next Java Enterprise</h3>
- <p>
- As of Wicket 8 we only support the Java Servlet API 3.1 (or newer). This means that to run applications built using Wicket 8 you have to run your application in a modern server like Tomcat 8.x, Jetty 9.1+ or a Java EE 7 compatible server.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-two-third">
- <h3>Lambdas in All The Right Places</h3>
- <p>
- The major feature of Java 8 was the addition of lambda support in the language. With Wicket 8 we have looked at providing lambda support in the API and have weighed it against performance and memory usage considerations.
- </p>
- <p>
- In this light we have opted to continue using subclassing as the primary extension mechanism for Wicket components.
- Factories for lambdas have been provided for various forms of models (databinding) and behaviors (adapters for components).
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Optional is Sometimes Required</h3>
- </div>
- <div class="l-one-third">
- <p>
- The new Optional type in Java 8 is intended for places in your API where things can be null. In Wicket’s case we have adopted Optional in just those places to clarify the API.
- </p>
- <p>
- For example the AjaxFallbackLink, a link that works using both with and without AJAX, now uses Optional to signify whether the link was clicked utilizing AJAX or normal request processing: the AJAX request is wrapped in an Optional. Previous versions of Wicket would provide a null value for the AJAX request.
- </p>
- <p>
- Because we have modified the API to utilize Optional, you will get compile errors when you start migrating to Wicket 8. This gives you the exact positions where these improvements have occurred and you can start working with the Optional API.
- </p>
- </div>
- <div class="l-two-third">
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="c1">// WICKET 7:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket7"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">AjaxRequestTarget</span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span>
-<span class="c1">// WICKET 8:</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">AjaxFallbackLink</span><span class="o"><</span><span class="nc">Void</span><span class="o">>(</span><span class="s">"wicket8"</span><span class="o">)</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">onClick</span><span class="o">(</span><span class="nc">Optional</span><span class="o"><</span><span class="nc">AjaxRequestTarget</span><span class="o">></span> <span class="n">target</span><span class="o">)</span> <span class="o">{</span>
- <span class="k">if</span><span class="o">(</span><span class="n">target</span><span class="o">.</span><span class="na">isPresent</span><span class="o">())</span> <span class="o">{</span>
- <span class="c1">// ...</span>
- <span class="o">}</span>
- <span class="o">}</span>
-<span class="o">});</span></code></pre></figure>
-
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-full">
- <h3>Models as Functional Interface</h3>
- <p>
- Wicket uses models as the databinding method: each data-aware component can take a model implementation to retrieve and store data in. From Wicket 8 we have made the root interface IModel a functional interface. You can now use lambdas where you can use models.
- </p>
- <p>
- The following example binds a Label component to the name of a person object in different ways using Wicket 8:
- </p>
-
-<figure class="highlight"><pre><code class="language-java" data-lang="java"><span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name1"</span><span class="o">,</span> <span class="nl">person:</span><span class="o">:</span><span class="n">name</span><span class="o">));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name2"</span><span class="o">,</span> <span class="o">()</span> <span class="o">-></span> <span class="n">person</span><span class="o">.</span><span class="na">getName</span><span class="o">()));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name3"</span><span class="o">,</span> <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">personModel</span><span class="o">,</span> <span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span>
-<span class="n">add</span><span class="o">(</span><span class="k">new</span> <span class="nc">Label</span><span class="o">(</span><span class="s">"name4"</span><span class="o">,</span>
- <span class="nc">LambdaModel</span><span class="o">.</span><span class="na">of</span><span class="o">(</span><span class="n">contractModel</span><span class="o">,</span> <span class="nl">Contract:</span><span class="o">:</span><span class="n">getPerson</span><span class="o">)</span>
- <span class="o">.</span><span class="na">map</span><span class="o">(</span><span class="nl">Person:</span><span class="o">:</span><span class="n">getName</span><span class="o">)));</span></code></pre></figure>
-
- <p>
- The new <code>LambdaModel</code> type in Wicket enables type safe, refactor safe databinding for components. Previously one would bind data to components using PropertyModel, using a string expression to determine the exact property to show. The string expression is something like <code>"person.name"</code>. This is inherently difficult to refactor when you decide to change the name field into for example <code>"lastName"</code>. With <code>LambdaModel</code>, this refactoring is t [...]
- </p>
-
- <p>
- Microbenchmarks have shown that using lambda models provides much better performance than the string based PropertyModel at the cost of slightly larger memory footprint.
- </p>
- </div>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-half">
- <h3>No Rewrite Necessary</h3>
- <p>
- The Wicket team has been very careful of adopting Java 8 technologies and as such you don’t have to rewrite your whole application, whilst still reaping all the benefits of Java 8.
- </p>
- <p>
- As this is a new major version we have, in accordance with semantic versioning, cleaned up many APIs and you will get compile errors when you migrate from previous Wicket versions.
- </p>
- </div>
- <div class="l-half">
- <h3>Migrating to Wicket 8</h3>
- <p>
- When you migrate from a previous Wicket version to Wicket 8, a full list of changes and migrations is available at the following page:
- </p>
- <p>
- <a href="https://s.apache.org/wicket8migrate">https://s.apache.org/wicket8migrate</a>
- </p>
- <p>
- Please consult this migration guide when you are moving towards Wicket 8.
- </p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-full">
- <h2>Getting Started with Wicket 8</h2>
- <p>
- It is very easy to get started with Wicket: use our <a href="/start/quickstart.html">quick-start wizard</a> or
- use one of the options below.
- </p>
- </div>
- <div class="l-half">
- <h3>Download using Apache Maven</h3>
- <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"><dependency></span>
- <span class="nt"><groupId></span>org.apache.wicket<span class="nt"></groupId></span>
- <span class="nt"><artifactId></span>wicket-core<span class="nt"></artifactId></span>
- <span class="nt"><version></span>8.8.0<span class="nt"></version></span>
-<span class="nt"></dependency></span></code></pre></figure>
-
- </div>
- <div class="l-half">
- <h3>Download sources/binaries manually</h3>
- <p>
- Or download and build the distribution yourself, or use our
- convenience binary package
- </p>
- <ul>
- <li>Source: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0">8.8.0 source download</a></li>
- <li>Binary: <a href="http://www.apache.org/dyn/closer.cgi/wicket/8.8.0/binaries">8.8.0 binary download</a></li>
- </ul>
- </div>
-</div>
-
-<hr />
-
-<div class="l-full l-first preamble">
- <h1 id="introduction">Introducing Apache Wicket</h1>
- <p>Invented in 2004, Wicket is one of the few survivors of the Java
- serverside web framework wars of the mid 2000's. Wicket is an open
- source, component oriented, serverside, Java web application framework.
- With a history of over a decade, it is still going strong and has a
- solid future ahead. Learn why you should consider Wicket for your next
- web application.</p>
-</div>
-
-<div class="l-first l-flex">
- <div class="l-one-third">
- <img src="/img/java-wicket-html5.png" class="l-full" />
- <h3>Just Java & HTML</h3>
- <p>Leverage what you know about Java or your favourite HTML
- editor to write Wicket applications. With pure Java code and HTML
- markup Wicket is the go-to web framework for purists.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-safe.png" class="l-full" />
- <h3>Secure by Default</h3>
- <p>URLs do not expose sensitive information and all component paths are
- session-relative. Wicket keeps your model private except those parts
- you explicitly expose.</p>
- </div>
- <div class="l-one-third">
- <img src="/img/wicket-components.png" class="l-full" />
- <h3>AJAX Components</h3>
- <p>Write Ajax applications without having to write a single line
- of JavaScript code. Wicket's Ajax functionality makes it trivial
- to update selected parts of a UI, and comes with a great selection
- of basic Ajax components.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Open Source with Apache License</h3>
- <p>Since its inception in 2004 Wicket has been an open source
- project and remains available under one of the most permissive
- licenses: the Apache Software License.</p>
- </div>
- <div class="l-one-third">
- <h3>Maintainable code</h3>
- <p>Pages and Components in Wicket are real Java objects that support
- encapsulation, inheritance and events. Create high level components
- with ease and bundle its stylesheets, JavaScript and other resources
- into one reusable package.</p>
- </div>
- <div class="l-one-third">
- <h3>Internationalized to take on the world</h3>
- <p>With support of over 25 languages out-of-the-box, Wicket let's
- you get started in your own language, or a second language with no
- effort. You can provide alternative languages on the application,
- page, or even component level.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Multi-tab and window support</h3>
- <p>No more pain while keeping taps on multiple tabs and windows.
- Wicket's automatic state storage ensures that your users can open
- pages in new tabs and windows without causing problems.</p>
- </div>
- <div class="l-two-third">
- <h3>Work with JavaScript and CSS</h3>
- <p>Global JavaScript libraries and CSS styling mix properly with
- component local JavaScript and CSS resources. You can use custom
- component libraries that ship with default JavaScript behaviour and
- CSS styling, without having to do anything yourself. Creating such
- self-contained component libraries is as easy as creating a JAR
- file.</p>
- </div>
-</div>
-<div class="l-first l-flex">
- <div class="l-one-third">
- <h3>Test your pages and components</h3>
- <p>With WicketTester you can achieve testing coverage your QA
- department can only dream of. Test your pages without having to run
- inside a browser, or start a container. Test your components directly,
- check their rendered markup tags, attributes and contents with ease.</p>
- </div>
- <div class="l-one-third">
- <h3>Injection support</h3>
- <p>Inject your services into your pages and components with the
- technology of your choosing: Wicket provides integration with CDI
- (JSR-305), Spring and Guice.</p>
- </div>
- <div class="l-one-third">
- <h3>JavaEE integration</h3>
- <p>If you are using the Web profile of JavaEE 6 or newer, you can
- leverage JPA, EJBs, Bean Validation and CDI with Wicket's integrations
- for these specifications.</p>
- </div>
-</div>
-<div class="l-first">
-</div>
-<hr />
-
-:ET
\ No newline at end of file
diff --git a/_sass/taiga/_base.scss b/_sass/taiga/_base.scss
index e870d3b..82670e1 100644
--- a/_sass/taiga/_base.scss
+++ b/_sass/taiga/_base.scss
@@ -126,3 +126,9 @@ dl {
main {
box-shadow: 0 .5rem 3rem #f0f0f0;
}
+
+.announce {
+ font-weight: bold !important;
+ font-size: 4rem;
+ color: rgb(48, 50, 132);
+}
\ No newline at end of file
diff --git a/content/atom.xml b/content/atom.xml
index 84c78a4..e1b475d 100644
--- a/content/atom.xml
+++ b/content/atom.xml
@@ -3,7 +3,7 @@
<title>Apache Wicket</title>
<link href="http://wicket.apache.org/atom.xml" rel="self"/>
<link href="http://wicket.apache.org/"/>
- <updated>2020-06-25T12:14:06+02:00</updated>
+ <updated>2020-06-25T12:26:28+02:00</updated>
<id>http://wicket.apache.org/</id>
<author>
<name>Apache Wicket</name>
diff --git a/content/css/style.css b/content/css/style.css
index 2fd4b01..4458d97 100644
--- a/content/css/style.css
+++ b/content/css/style.css
@@ -76,6 +76,8 @@ dl.advanced dd { width: 66.6666666667%; margin-left: 0%; margin-right: 0%; }
main { box-shadow: 0 .5rem 3rem #f0f0f0; }
+.announce { font-weight: bold !important; font-size: 4rem; color: #303284; }
+
.l-full { width: 100%; float: none; }
@media (min-width: 960px) { .l-full { width: 95.8333333333%; margin-left: 2.0833333333%; margin-right: 2.0833333333%; } }
diff --git a/content/css/style.css.map b/content/css/style.css.map
index 4bcc5d4..898968a 100644
--- a/content/css/style.css.map
+++ b/content/css/style.css.map
@@ -27,7 +27,7 @@
"// =========== Settings\n\n// Most of the variables are based on some kind of percentages to maintain stability.\n// So $variable-10 is small or light and $variable-100 is big or dark.\n\n\n// Set your own font\n$font-family-body: \"Source Sans Pro\", sans-serif;\n$font-family-heading: \"Source Sans Pro\";\n\n// The base font-size, all other elements will adjust to this value\n$font-size-base: 15px;\n\n$font-size-10: 0.75rem;\n$font-size-20: 0.875rem;\n$font-size-30: 1rem;\n$font-size [...]
"// =========== Mixins\n\n// Animations\n// Example: .element { @include animation(keyframe-name, 500ms, default); }\n@mixin animation ($name: true, $duration: true, $timing_function: true, $delay: false, $iteration_count: false, $direction: false) {\n @if $name { -webkit-animation-name: $name; -moz-animation-name: $name; -ms-animation-name: $name; }\n @if $duration { -webkit-animation-duration: $duration; -moz-animation-duration: $duration; -ms-animation-duration: $duration; }\n [...]
"// =========== Grid\n\n// Use '@include grid(12, 2)' to make a column.\n// The first unit (12) is the column width.\n// The second unit (2) is the margin on both sides.\n// The margin will be auto substracted from the column width.\n// So don't recalculate the column width if you change your margin.\n\n// To set different margins on both sides use '@include grid(12, 2, 3)'.\n// You can also use negative margins.\n\n$grid-column: 100% / $grid-columns;\n\n@mixin col($n: 1) { width: ($n [...]
- "// =========== Base\n\nhtml, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, menu, nav, output, ruby, section, summary, [...]
+ "// =========== Base\n\nhtml, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, menu, nav, output, ruby, section, summary, [...]
"// =========== Layout\n\n.l-full {\n @include breakpoint($breakpoint-30) { @include grid(48, 1); }\n width: 100%;\n float: none;\n}\n\n.l-two-third {\n\n @include breakpoint($breakpoint-30) { @include grid(32, 1); }\n}\n\n.l-half {\n\n @include breakpoint($breakpoint-30) { @include grid(24, 1); }\n}\n\n.l-one-quarter {\n @include breakpoint($breakpoint-30) { @include grid(12, 1); }\n}\n\n.l-one-eigth {\n @include breakpoint($breakpoint-30) { @include grid(6, 1); } [...]
"// =========== States\n\n.is-hidden { display: none !important; }\n\n.is-hidden, .is-invisible { visibility: hidden !important; }\n\n.is-active, .is-visible { display: block; }\n\n.left { @include breakpoint($breakpoint-10) { float: left; } }\n\n.right { @include breakpoint($breakpoint-10) { float: right; } }\n\n.text-left { text-align: left; }\n\n.text-right { text-align: right; }\n\n.text-center { text-align: center; }\n\n.nowrap { white-space: nowrap; }\n\nimg.desaturated {\n -w [...]
"// =========== Buttons\n\nbutton::-moz-focus-inner,\ninput::-moz-focus-inner {\n border: 0;\n padding: 0;\n}\n\n%button {\n -webkit-appearance: none;\n -moz-appearance: none;\n appearance: none;\n border: 0;\n border-radius: $border-radius-10;\n cursor: pointer;\n display: inline-block;\n font-family: $font-family-body;\n font-size: $font-size-30;\n -webkit-font-smoothing: antialiased;\n -moz-osx-font-smoothing: grayscale;\n font-weight: bold; [...]
@@ -42,5 +42,5 @@
"\n.wicket8 {\n nav.mainmenu {\n a, a:active, a:hover {\n color:$almost-black;\n }\n }\n\n .header {\n color:$almost-black;\n }\n .jumbotron {\n &.header{\n background-color:#BF866F;\n background-image: url('../img/background-4.jpg');\n background-repeat: no-repeat;\n background-position: center 50%;\n background-size: cover;\n box-shadow: none;\n }\n .j [...]
],
"names": [],
- "mappings": "AAAA,OAAO,CAAC,4CAAI;AACZ,OAAO,CAAC,4CAAI;AKCZ,AAAA,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,E [...]
+ "mappings": "AAAA,OAAO,CAAC,4CAAI;AACZ,OAAO,CAAC,4CAAI;AKCZ,AAAA,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,E [...]
}
\ No newline at end of file
diff --git a/content/index.html b/content/index.html
index bb06b1c..002202a 100644
--- a/content/index.html
+++ b/content/index.html
@@ -121,16 +121,14 @@
</section>
<section>
<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
+ <h1 id="introduction" class="announce">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
+ <div>
+ <img src="/img/logo.svg" alt="Apache Wicket" width="200" height="200" />
+ </div>
</div>
<div class="l-first">
<div class="l-full">
diff --git a/index.md b/index.md
index f89763a..d32c975 100644
--- a/index.md
+++ b/index.md
@@ -18,16 +18,14 @@ jumbotronLinks:
---
<div class="l-full l-first preamble">
- <h1 id="introduction">Announcing Apache Wicket 8: Write Less, Achieve More</h1>
- <div>
- <img src="{{ site.baseurl }}/img/logo.svg" alt="Apache Wicket" width="200" height="200">
- </div>
- <p>
- The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
- </p>
+ <h1 id="introduction" class="announce">Announcing Apache Wicket 9: get into the modern Java world!</h1>
<p>
+ The Apache Wicket project announces the 9th major release of the open source Java web framework servicing websites and applications across the globe since 2004.
Built on top of Java 11, this version of Wicket brings web development into the modern Java world, offering a fundamental tool to keep you code up to date with Java evolution.
</p>
+ <div>
+ <img src="{{ site.baseurl }}/img/logo.svg" alt="Apache Wicket" width="200" height="200">
+ </div>
</div>
<div class="l-first">
<div class="l-full">