I'd been looking around for a way to do this and someone responded with some information in stackoverflow.com, but it was still a little over my head unfamiliar as I am with Wicket. So I got some help from a friend on Wicket internals.

This is an excerpt from my Sample.html file that wants to display the contents of script files that make good examples:

view source
print?
01....
02.<h2> Sample scripts </h2>
03. 
04.<p>
05.A picture is worth a thousand words...
06.</p>
07. 
08.<h4> <i>create.cmd</i>: </h4>
09.<div style="margin-left: 40px">
10.    <pre wicket:id="create" />
11.</div>
12. 
13.<h4> <i>short.suite</i>: </h4>
14.<div style="margin-left: 40px">
15.    <pre wicket:id="suite" />
16.</div>
17....

For each Wicket id, I have to create a Label in TestClientSample.java. It's a bit of a pain, but what I get is priceless.

view source
print?
1.public Sample()
2.{
3.    super();
4. 
5.    add( new FileContentLabel( "create", "/samples/create.cmd" ).setEscapeModelStrings( false ) );
6.    add( new FileContentLabel( "suite",  "/samples/short.suite" ).setEscapeModelStrings( false ) );
7.}

The magic is extending Wicket's Lable class. See the Java code below that also contains the file I/O.

The one fly in the ointment was that file I/O isn't totally obvious from a servlet, to wit, just where are my files in the first place? So, I googled around to figure out how to do it using ServletContext. That was a little confusing since I hadn't written the servlet myself and didn't know where to go to satisfy it until Thomas reminded me that Wicket has you inherit from its WebApplication. I added the following to my Application class. (Always useful to work alongside a genius!)

view source
print?
01.public class Application extends WebApplication
02.{
03.    private static ServletContext context = null;
04. 
05.    public Application()
06.    {
07.        // can't get ServletContext here: don't try it!
08.    }
09. 
10.    protected void init()
11.    {
12.        context = this.getServletContext();
13.    }
14. 
15.    public static String getRealpath( String path )
16.    {
17.        // let Tomcat tell us where this path really is...
18.        return context.getRealPath( path );
19.    }
20. 
21.    ...

I spent a little more time doing it this afternoon than I really had, but it will save me countless hours updating my script examples by hand in our portal app. Earlier already, I WAR'd up our sample scripts to go out downloadable from one of our portal pages, so they were already sitting in my deployed application under webapps.

FileContentLabel.java:

If I haven't mucked the line numbering, the various magic of this solution happens below on lines

• 25, extend Label —since we're creating a "nifty" sort of Label
• 45, getRealPath() —to find out the actual path to my scripts
• 55, setDefaultModel() —to work the magic of Wicket content injection

view source
print?
01.package com.hp.web.demoapp.extensions;
02. 
03.import java.io.BufferedReader;
04.import java.io.File;
05.import java.io.FileReader;
06.import java.io.IOException;
07. 
08.import org.apache.log4j.Logger;
09.import org.apache.wicket.markup.html.basic.Label;
10.import org.apache.wicket.model.Model;
11. 
12.import com.hp.web.demoapp.page.Application;
13. 
14./**
15. * Include simple file content in an HTML page.
16. *
17. * Thomas figured out that Wicket's Label needed to be extended to create the capability
18. * of including static file content from (text) files, in our case, just the contents of
19. * script files for use in our portal examples.
20. *
21. * After reading the file, you just use Component.setDefaultModel() to work the magic.
22. *
23. * @author Russell Bateman
24. */
25.public class FileContentLabel extends Label
26.{
27.    private static Logger       log = Logger.getLogger( FileContentLabel.class );
28.    private static final long   serialVersionUID = 1L;
29.    private static final String newline = "\n";
30. 
31.    /**
32.     * Constructor that reads the file and shoves it into the Model.
33.     *
34.     * @param wicketid of the label.
35.     * @param filepath to file whose contents are to be included.
36.     */
37.    public FileContentLabel( String wicketid, String filepath )
38.    {
39.        super( wicketid );
40. 
41.        String contents = null;
42. 
43.        try
44.        {
45.            contents = readFileContents( Application.getRealpath( filepath ) );
46. 
47.            if( contents == null || contents.length() < 1 )
48.                contents = "(missing file)";
49.        }
50.        catch( IOException e )
51.        {
52.            log.warn( "IOException reading included content " + filepath );
53.        }
54. 
55.        setDefaultModel( new Model< String > contents ) );
56.    }
57. 
58.    private static String readFileContents( String filepath ) throws IOException
59.    {
60.        File           f = new File( filepath );
61.        BufferedReader reader;
62.        String         line;
63.        StringBuffer   buffer = new StringBuffer();
64. 
65.        if( !f.exists() )
66.            return null;
67. 
68.        reader = new BufferedReader( new FileReader( filepath ) );
69. 
70.        do
71.        {
72.            line = reader.readLine();
73. 
74.            if( line != null )
75.            {
76.                buffer.append( line );
77.                buffer.append( newline );
78.            }
79.        }
80.        while( line != null );
81. 
82.        reader.close();
83. 
84.        return buffer.toString();
85.    }
86.}

There's a knack to debugging Wicket that comes with experience. Much of what goes awry can be summed up thus:

1. Something asked for by the HTML mark-up is not supported by anything in Java.
2. Something supported by Java is done in such a way, via an add() method call, that requires echoing in the HTML mark-up.
3. Mixed: something used in HTML is misspelled or otherwise assuming a name that wasn't created in Java.

The second two cases are typically more prevalent than the first in a project undertaken by Java developers.

Hint: when tracking down what's missing/misspelled/extra, it's often necessary to walk the Java hierarchy. A page composition extending another class that does composition work will exhibit trouble that won't be diagnosed without crawling up the class hierarchy. (This may be obvious, but...)

Wicket expresses the first problem as:

    No get method defined for class: class <fully-qualified-classname> expression: <missing variable, etc. >

Wicket expresses the second phenomenon as:

    The component(s) below failed to render. A common problem is that you have added a component in code but
       forgot to reference it in the markup (thus the component will never be rendered).

Wicket then goes on sometimes to name the rendering component and id.

Methodology

Other than what was said higher up here, what I can say is that when I see a Wicket crash, the first thing I do is start looking for field elements (ids) from my page, then I look for any classes I wrote and line numbers in those classes. There's a lot of garbage to sort through; look for element ids, like forgotten in the following error:

Last cause: The component [WebMarkupContainer [Component id = dropdownSpan]] was rendered already. You can render it only once during a render phase. \
Class relative path: org.apache.wicket.markup.html.WebMarkupContainer:paymentCreateForm:forgotten:dropdownSpan

(The problem here was that I was trying to use forgotten twice in the HTML.)