Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How can I install the Wicket framework?

Tags:

java

wicket

How can I install the Wicket framework? Please guide me!

like image 344
Ant's Avatar asked Feb 14 '11 16:02

Ant's


People also ask

How do I run a wicket application?

5 small steps to a web applicationFill in the Maven coordinates for your project in the wizard and select the appropriate Wicket version. Copy the generated commandline to your clipboard and paste it in a terminal (or a DOS box) Open the project in your IDE of choice. Start the Start class in the src/test/java folder.

How does a wicket framework work?

Wicket is a Java server-side web component-oriented framework that aims at simplifying building web interfaces by introducing patterns known from desktop UI development. With Wicket it is possible to build a web application using only Java code and XHTML compliant HTML pages.

What is Apache Wicket used for?

About Apache Wicket It features a POJO data model, no XML, and a proper mark-up / logic separation not seen in most frameworks. Apache Wicket gives you a simple framework for creating powerful, reusable components and offers an object oriented methodology to web development while requiring only Java and HTML.

What is Wicket technology?

Meet Wicket Our technology provides customers with the tools to offer a fast, touchless, and more convenient experience for both guests and staff. With deployments at large venues, enterprises, and retail spaces across the country, Wicket has a proven facial recognition and authentication solution for any facility.


2 Answers

Here are step-by-step instructions I put together a few months ago for installing Wicket. They list everything I did to set Wicket up on a vanilla machine with Eclipse installed.


  • Downloaded JDK 6_22
  • Downloaded Maven 3.01
  • Installed JDK to C:\Program Files\Java\jdk1.6.0_22
  • Unzipped maven to C:\Program Files\apache-maven-3.0.1

  • Updated system environment variables:

    • M2
      C:\Program Files\apache-maven-3.0.1
    • M2_HOME
      %M2_HOME%\bin = C:\Program Files\apache-maven-3.0.1\bin
    • JAVA_HOME
      C:\Program Files\Java\jdk1.6.0_22
    • M2_REPO
      C:\Users\[username]\.m2\repository (exact path will vary based on your username/Windows version)

  • Followed instructions at Wicket quickstart, generating this Maven command:

    mvn archetype:create
    -DarchetypeGroupId=org.apache.wicket
    -DarchetypeArtifactId=wicket-archetype-quickstart
    -DarchetypeVersion=1.4.1
    -DgroupId=com.mycompany
    -DartifactId=projName
    
  • Ran above Maven command from command line

  • Relevant files, including Wicket source, were downloaded automatically, based on POM.
  • Ran mvn eclipse:eclipse to create an Eclipse project based on above
  • Imported project into Eclipse with File > Import..., Existing Projects

  • Ran Start.java in the test folder and found the test app up and running at http://localhost:8080

Optional: support for third-party code, like Wicket Extensions
Manually adding the Wicket Extensions JAR file to to the M2_REPO directory won't work.

Instead, run mvn clean dependency:copy-dependencies after updating the POM. (Wicket Extensions is included but commented out in the default POM.) Then configure the build path in Eclipse by using Add Variables... (not Add JARs), select M2_REPO, press Extend, find the desired JAR (in this case, Wicket Extensions).

A similar procedure should work for other third-party libraries.


I was originally going to keep updating this web page with more instructions, but I've been working on other things lately. Eventually, though, I hope to get around to instructions on how to configure Wicket with Tomcat instead of relying solely on the jetty server it comes with.

UPDATE

Instructions for deploying to Tomcat are here:

  • Download and install Apache Tomcat and Apache Ant.

  • Create the following directory structure:

    \WicketTomcat
      +---src
      | +---main
      | | +---java
      | | | \---com
      | | |   \---HelloWicket
      | | |         HelloWorld.java
      | | |         HelloWorld.html
      | | |         HelloWorldApplication.java
      | | \---webapp
      | |   \---WEB-INF
      | |         web.xml
      | \---test
      |   \---java
      +---lib
      |     junit.jar
      |     log4j.jar
      |     servlet-api.jar
      |     slf4j-api.jar
      |     slf4j-log4j.jar
      |     wicket.jar
      |     wicket-extensions.jar
      +---target
        build.xml
    
  • Fill in the files as follows:

HelloWorld.java

package com.HelloWicket;

import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;

public class HelloWorld extends WebPage {
    public HelloWorld() {
        add(new Label("message", "Hello, Wicket!"));
    }
}

HelloWorld.html

<html>
<head>
<title>Wicket Tomcat test title</title>
</head>
<body>
    <span wicket:id="message">Message goes here</span>
</body>
</html>

HelloWorldApplication.java

package com.HelloWicket;

import org.apache.wicket.Page;
import org.apache.wicket.protocol.http.WebApplication;

public class HelloWorldApplication extends WebApplication {
    public HelloWorldApplication() {
    }

    /**
     * @see org.apache.wicket.Application#getHomePage()
     */
    @Override
    public Class<? extends Page> getHomePage() {
        return HelloWorld.class;
    }
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
    <display-name>Extremely simple example of deploying Wicket on Tomcat</display-name>
    <context-param>
        <param-name>configuration</param-name>
        <param-value>development</param-value> <!-- Wicket mode (development or deployment) -->
    </context-param>
    <filter>
        <filter-name>HelloWicket</filter-name> <!-- To be used in filter-mapping > filter-name below -->
        <filter-class>
            org.apache.wicket.protocol.http.WicketFilter
        </filter-class>
        <init-param>
            <param-name>applicationClassName</param-name>
            <param-value>
                com.HelloWicket.HelloWorldApplication <!-- Fully qualified name of WebApplication class -->
            </param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>HelloWicket</filter-name> <!-- Must match filter > filter-name above -->
        <url-pattern>/*</url-pattern> <!-- Take control of all URLs that start with http://localhost:8080/HelloWicket/  -->
    </filter-mapping>
</web-app>

<!--
After deploying to Tomcat, access with http://localhost:8080/HelloWicket/.

Source: http://wicket.apache.org/learn/examples/helloworld.html
-->

build.xml

<?xml version="1.0" encoding="UTF-8"?>
<project default="war" name="HelloWicket" basedir=".">
    <property name="final.name" value="HelloWicket" />
    <property name="src.main.dir" value="src/main/java" />
    <property name="src.test.dir" value="src/test/java" />
    <property name="src.web.dir" value="src/main/webapp" />
    <property name="lib.dir" value="lib" />
    <property name="build.dir" value="target" />
    <property name="build.main.classes" value="${build.dir}/classes" />
    <property name="build.test.classes" value="${build.dir}/test-classes" />
    <property name="build.test.reports" value="${build.dir}/test-reports" />
    <property name="build.reports.dir" value="${build.dir}/reports" />
    <property name="tomcat.dir" value="..\..\..\..\Program Files\Apache Software Foundation\apache-tomcat-7.0.22\webapps" />

    <path id="build.classpath">
        <fileset dir="${lib.dir}">
            <include name="**/*.jar" />
        </fileset>
    </path>
    <target name="clean">
        <delete dir="${build.dir}" failonerror="false" />
        <delete file="${final.name}.war" failonerror="false" />
    </target>
    <target name="init">
        <mkdir dir="${build.dir}" />
    </target>
    <target name="compile" depends="init">
        <mkdir dir="${build.main.classes}" />
        <javac destdir="${build.main.classes}" target="1.6" source="1.6" srcdir="${src.main.dir}" classpathref="build.classpath" includeantruntime="false" />
        <copy todir="${build.main.classes}">
            <fileset dir="${src.main.dir}">
                <include name="**/*.*" />
                <exclude name="**/*.java" />
            </fileset>
        </copy>
    </target>
    <target name="test-compile" depends="compile">
        <mkdir dir="${build.test.classes}" />
        <javac destdir="${build.test.classes}" target="1.6" source="1.6" srcdir="${src.test.dir}" includeantruntime="false">
            <classpath>
                <path refid="build.classpath" />
                <pathelement path="${build.main.classes}" />
            </classpath>
        </javac>
        <copy todir="${build.test.classes}">
            <fileset dir="${src.test.dir}">
                <include name="**/*.*" />
                <exclude name="**/*.java" />
            </fileset>
        </copy>
    </target>
    <target name="test" depends="test-compile">
        <mkdir dir="${build.test.reports}" />
        <junit dir="./" failureproperty="test.failure" printSummary="yes" fork="true" haltonerror="true">
            <sysproperty key="basedir" value="." />
            <formatter type="xml" />
            <classpath>
                <path refid="build.classpath" />
                <pathelement path="${build.main.classes}" />
                <pathelement path="${build.test.classes}" />
            </classpath>
            <batchtest todir="${build.test.reports}">
                <fileset dir="${src.test.dir}">
                    <include name="**/*Test*.java" />
                </fileset>
            </batchtest>
        </junit>
        <mkdir dir="${build.reports.dir}" />
        <junitreport todir="${build.reports.dir}">
            <fileset dir="${build.test.reports}">
                <include name="TEST-*.xml" />
            </fileset>
            <report format="frames" todir="${build.reports.dir}" />
        </junitreport>
    </target>
    <target name="war" depends="test">
        <war destfile="${build.dir}/${final.name}.war" webxml="${src.web.dir}/WEB-INF/web.xml">
            <lib dir="lib">
                <include name="wicket*.jar" />
                <include name="slf4j*.jar" />
                <include name="log4j*.jar" />
                <include name="servlet*.jar" />
            </lib>
            <classes dir="${build.main.classes}" />
            <fileset dir="${src.web.dir}">
                <include name="**/*" />
                <exclude name="**/web.xml" />
            </fileset>
        </war>
    </target>

    <target name="deploy" depends="war">
        <echo>Deploying .war to local Tomcat</echo>
        <copy todir="${tomcat.dir}">
            <fileset dir="${build.dir}" includes="${final.name}.war" />
        </copy>
    </target>
</project>

As I did with the original answer, I posted a slightly more explanatory version of this answer here, but this should really be enough to get you going.

like image 100
Pops Avatar answered Oct 24 '22 10:10

Pops


Make sure you have maven2 installed, then go to http://wicket.apache.org/start/quickstart.html, copy the command line from there and run it. That should create a project with a demo application and page that you can import in your favourite IDE and play with.

like image 27
Costi Ciudatu Avatar answered Oct 24 '22 10:10

Costi Ciudatu