Apache Wicket Fundamentals

Partager par email


Intensive and hands-on, the course emphasizes becoming productive quickly as a Wicket developer.

The Apache Wicket Framework covers the fundamentals from creating a basic web site to developing a multitiered architecture.

You will learn the Component Library, Session Management, Ajax, Events, Behaviors and the integration of Spring and Hibernate.

Code Titre Durée Prix HT
wicket01 Apache Wicket Fundamentals 5 jours Nous consulter


  • Why to adopt wicket, and how it compares to other frameworks
  • Best-practices, tips, and tricks to over come commonly encountered adoption obstacles
  • Build a database-drive, web application using Wicket


Existing Java web developers needing to learn Wicket.


Professional programming experience in Java is required especially with Spring, Hibernate. Knowing HTML, CSS, Ajax, JavaScript will be helpful.





1 What is Wicket?

What problems does Wicket solve?

Wicket in a nutshell Just Java / Just HTML / The right abstractions

Have quick examples of Wicket

Hello World! / Having fun with links / The Wicket echo application

2 The architecture of Wicket

2.1 How Wicket handles requests

Request-handling objects / The processing steps involved in request handling


2.2 Introducing Wicket components

The component triad / Wicket’s Java components

Page: one component to rule them all / Components and markup

Separation of presentation and logic: a good thing?

The component’s data brokers: models / Extending components with behaviors

3 Building a Wicket application

3.1 Introducing Application/ Setting up shop / Designing the user interface

3.2 Creating the store front / Cutting to the cheese / Adding the shopping cart

Going to check out / Adding pagination to the list of products

3.3 Creating the checkout page / Adding the billing address form

Adding validation to the billing-address form / Creating a reusable shopping cart

4 Understanding models

4.1 What are models?

4.2 A taste of the standard models

Using the simple Model

Using PropertyModels for dynamic models

Saving code with CompoundPropertyModels

4.3 Keeping things small and fresh: detachable models

What is detaching?

Working around a serialization problem with detachable models

Using LoadableDetachableModel

4.4 Nesting models for fun and profit

Working with components: labels, links, and repeaters

5.1 What are components?

5.2 Displaying text with label components

Using the Label component to render text

Displaying multiple lines using a MultiLineLabel

Displaying formatted text using labels

5.3 Navigating using links

Linking to documents using static links

Using ExternalLink to render links programmatically

Linking to Wicket pages with BookmarkablePageLinks

Adding bookmarkable links automatically with wicket:link

5.4 Responding to client actions with a link

Using Link to respond to client actions

Using AjaxFallbackLink to respond to client actions

5.5 Using repeaters to repeat markup and components

Using the RepeatingView to repeat markup and components

Using a ListView to repeat markup and components

5.6 Performing common tasks with components

Hiding parts of a page

Manipulating markup attributes / Removing excess markup

6 Processing user input using forms

6.1 What are forms?

6.2 How does form processing work?

Submitting a form from the browser to the server

Processing the form submission on the server

6.3 Components for text input

Using a TextField to process single-line text

Using a PasswordTextField to process a password

Using a TextArea to process multiline text

6.4 Selecting from a list of items

Selecting a single value from a list of choices

Selecting multiple values from a list of choices

Mapping an object to a choice and back using a ChoiceRenderer

Using check boxes for boolean properties

Components for submitting form data

Using buttons to submit data

Using links to submit data

Using Ajax to submit data

Skipping Wicket’s form processing

6.6 Validating user input

Making a field required / Converting user input from strings to domain types

Using Wicket’s supplied validators / Writing your own validator

6.7 Providing feedback

Feedback messages

Using the info, error, and warn methods for general messages

Displaying feedback messages using a FeedbackPanel

7 Composing your pages

7.1 Grouping components

Grouping components on a page: WebMarkupContainer

Reusing grouped components by creating a Panel

Grouping components using fragments

7.2 Page composition: creating a consistent layout

Creating consistent layouts using plain pages

Creating consistent layouts using markup inheritance

Creating consistent layouts using panels


eclipse java spring hibernate ajax


apache wicket Spring hibernate java