jWebApp Quick Start

 

jWebApp is a Java servlet-based model-view-controller web application framework that is specifically designed to satisfy the need for extremely simple web development.  In fact, jWebApp is so simple, it can actually be learned in a matter of minutes.

 

jWebApp is as easy as:

 

    public class HelloWorld extends RequestHandler

      {

        public String hello()

          {

            getServerInterface().addViewObject("helloWorld", "Hello World");

           

            return "/WEB-INF/helloWorld.jsp";

          }

      }

 

Just plain HTML and your favorite template markup:

 

    <div align="center">

        <h3>Hello, This Is A Simple "Hello World" Example.</h3>

        <h2>${helloWorld}</h2>   

    </div>

 

Calling the above is simple:

 

    http://host/context/helloWorld/hello

 

The following servlet configuration is all that is needed (outside our control, it's a servlet thing):

 

    <servlet>

        <servlet-name>jwaRequestServlet</servlet-name>

        <servlet-class>jwebapp.RequestServlet</servlet-class>

    </servlet>

   

    <servlet-mapping>

        <servlet-name>jwaRequestServlet</servlet-name>

        <url-pattern>/helloWorld/hello</url-pattern>

    </servlet-mapping>

 

That's it! No other XML, annotation, or configuration is needed!

 

jWebApp provides support for all of the features you expect, but does not need additional tag libraries or extensive APIs to implement them, what you already know is all you will need.  With jWebApp, you can use any model/business layer technologies, any database-access technologies, any web-authoring technologies, and plain old HTML and HTML forms.  

 

Class Mapping

 

With jWebApp you have a configuration free mode where you simply drive the web application with URIs.  jWebApp automatically finds the class instance required to satisfy a request. 

 

For example, with the following URL:

 

http://www.website.com/application/HelloWorld

 

jWebApp would, by default, find a class named [webapp.][application.]HelloWorld.class. 

 

jWebApp will automatically load the class and, by default, call the method “validateRequest” if it exists.  jWebApp then calls the method “request” which must exist (or an HTTP not found error is returned).

 

The URI can be anything as long as all or part of it identifies a locatable class.  All of jWebApp’s functionality is available in code and the methods only need to return a forwarding URI, which can be another request handler or a final destination such as a JSP or Velocity page.  The methods can also return NO_FORWARDING if there is no need for forwarding (no data is returned to the client).

 

Method Mapping

 

jWebApp also provides for mapping web requests to methods within a class.

 

As another example, with the following URL:

 

http://www.website.com/application/manageUsers/newUser

 

jWebApp would, by default, find a class named [webapp.][application.]ManageUsers.class.  jWebApp loads an instance of the class and optionally calls the method “validateNewUser” if it exists.  jWebApp then calls the method “newUser” which must exist (or an HTTP not found error is returned).

 

REST

 

jWebApp provides another configuration free mode that provides server side support for REST (RESTful web services).  REST is based on HTTP concepts, and is simply the use of the 6 most common HTTP request methods (POST, GET, PUT, DELETE, HEAD and OPTIONS).  Which, as defined in both HTTP and REST, correspond to CRUD type operations:

 

POST (create - also insert, update, delete, append)

GET (read - also select, get)

PUT (update - also insert, update, replace)

DELETE (delete - also remove, cut)

HEAD (same as get without data/body - just headers)

OPTIONS (what HTTP methods are supported)

 

Regular jWebApp request handling is also RESTful (for GET and POST only) as long as the GET request handles read only operations with no side effects (no updates, deletes, state changes, etc.)  Requests are also RESTful if they have query strings.  By definition, REST does not allow for session tracking or cookies (they are still available with jWebApp), and authentication (also available with jWebApp) is handled as defined for HTTP (via request headers).

 

Configuration Mode (Optional)

 

jWebApp also provides a completely optional, but simple, XML configuration mode which consists of:

 

<jwebapp>

    <request id="" match="" matchRegExp="" secureConnection=""

                            handlerClass="" handlerMethod=””>

        <security role="" />

        <parameter name="" value="" />

        <forward id="" key="" protocol="" url="" rewrite=""/>

        <redirect id="" key="" protocol="" url="" rewrite=""/>

        <validation id="" parameterName="" type="" arguments="" errorMessage=""/>

    </request>

       

    <jwaUrl id="" protocol="" url="" rewrite=""/>

    <message id="" value="" />

</jwebapp>

 

This mode provides the ability for class and method reuse, passing in static parameters, regular expression matching of URIs, soft coded URIs, and soft coded messages.  jWebApp configuration even allows overriding configuration free and other configurations.  The configuration mode also provides for XML defined security, forwarding, redirects and validation.

 

See the configuration manual for more details.

 

Request Handler

 

In both configuration free and configuration based cases, the request handler is a class that extends RequestHandler (RestfulHandler for REST), for example:

 

public class MyRequestHandler extends RequestHandler

  {

    // optional validator

    public String validateRequest(ServerInterface serverInt) { … }

 

    // default handler

    public String processRequest(ServerInterface serverInt) { … }

 

    // optional validator

    public String validateNewUser(ServerInterface serverInt) { … }

    public String processNewUser(ServerInterface serverInt) { … }

  }

 

For RESTful web services:

 

public class MyRestfulHandler extends RestfulHandler

  {

    // Handles HTTP GET request.

    public String get(ServerInterface serverInterface, String[] args) { ... }

   

    // Handles HTTP HEAD request.

    public String head(ServerInterface serverInterface, String[] args) { ... }

 

    // Handles HTTP PUT request.

    public String put(ServerInterface serverInterface, String[] args) { ... }

 

    // Handles HTTP POST request.

    public String post(ServerInterface serverInterface, String[] args) { ... }

 

    // Handles HTTP DELETE request.

    public String delete(ServerInterface serverInterface, String[] args) { ... }

 

    // Handles HTTP OPTIONS request.

    public String options(ServerInterface serverInterface, String[] args) { ... }

  }

 

All parameters are optional and you can also use HttpServletRequest and/or HttpServletResponse as parameters.

 

In a configuration free mode, the only need is for the class to be in the package “webapp” (default), which is optionally definable in the web.xml file via the init parameter “classPrefix”:

 

<init-param>

    <param-name>classPrefix</param-name>

    <param-value>webapp</param-value>

</init-param>

 

And of course, the class/JAR files need to be locatable (usually in the WEB-INF/classes and/or WEB-INF/lib directory).

 

That’s it, that’s all there is to jWebApps configuration free automatic URI mapping!

 

Setting Up a jWebApp Project

 

Installing a jWebApp project is simply a matter of copying the “jwebapp_XX.war“ file of choice to your web server’s auto-deploy directory “webapps”.  Your web server will automatically unpack and install the web application.  You can also simply unzip the archive (WARs are zip files).  It’s also possible to rename the “.war” file to “.zip” and unzip the archive.

 

Once installed simply start development of your webapp.

 

Installing a Web Server

 

If you need a web server, simply download and install Apache’s Tomcat, Coucho’s Resin or Jetty. They are free and easy to install and run.  There are many J2EE web servers that you can also use.

 

Resin is extremely easy on Windows’ platforms.  Simply unzip Resin in the directory of your choice and run ‘httpd.exe’.  Copy the ‘jwebapp_XX.war’ file to the webapps directory and you’re done.

 

A Typical jWebApp Project Layout

 

jWebApp is easy to set up and use with your projects, and follows the typical setup for Java web technology applications:

 

/

/images/

/WEB-INF/

/WEB-INF/classes/

/WEB-INF/content/

/WEB-INF/include/

/WEB-INF/lib/

/WEB-INF/web.xml

/WEB-INF/webapp.xml

/WEB-INF/mainpage.jsp

index.jsp

 

 

where ‘/’ is any directory you like. This is our typical setup, but you are free to use any workable setup you like.  In a configuration free mode the webapp.xml file is not needed.  But even in a configuration free mode it’s still quite useful for defining non-hardcoded URIs and messages.

 

The JAR files in the “WEB-INF/lib” directory can also be located in your web server’s “common” or “shared” lib directory (container dependent), where they will be available to all applications.  However, if you’re working with multiple versions of a jar, it may be better to keep them in the project’s lib directory to keep them isolated from other applications.

 

Working with jWebApp is no different than working with any other Java web technology, only much simpler.

 

 

Page Authoring

 

Page authoring can be handled with any view technology you like.  JSP/JSTL is a good choice, and so is Apache’s Velocity. 

 

All attributes set with getServerInterface().addViewObject() and getServerInterface().setAttribute(), which simply calls the servlet request’s setAttribute(), are available to the page author via JSP or Velocity expressions:

 

${attributeName}

 

Servlets provide several implicit objects (such as ${param}) that are always available to the page author.  jWebApp also provides several implicit objects, summarized by the following table:

 

${jwaUrl.id}	provides URLs as defined in the jwaUrl, forward, and redirect definitions in your configuration file
${jwaMessage.id}	Access messages defined in the XML configuration file
${requestContextPath}	The servlet context
${requestServletPath}	The servlet path (exact or path oriented paths only)
${requestPathInfo}	The request extra path information (follows servlet path)
${requestQueryString}	The request query string
${ requestUri}	The request URI
${ requestUrl}	The request URL
${ requestScheme}	The request scheme (http, https, etc.)
${ requestServerName}	The server name the request called
${ requestServerPort}	The port the request called
${ requestLocalName}	The local server name
${ requestLocalPort}	The local port name
${jwaRemoteUser}	Contains the remote user id
${jwaRemoteUserInformation}	provides the following properties for accessing user information:   ${jwaRemoteUserInformation.userId}, ${jwaRemoteUserInformation.salutation}, ${jwaRemoteUserInformation.firstName}, ${jwaRemoteUserInformation.lastName}, ${jwaRemoteUserInformation.roleMap}

 

• An extremely easy Java-based web application framework
• Full stack web development (includes jPersist)
• Model-View-Controller architecture
• Incredibly easy server side AJAX support
• Full support for RESTful web services
• Simple configuration free web applications
• Easy-to-use URL to object mapping
• Extremely small learning curve (learn in minutes)
• All the functionality offered by other frameworks and more
• No proprietary tag libraries and no need for any
• Use JSP/JSTL, Velocity, or whatever you like
• Use regular HTML and Forms
• Optionally use any BSF compatible scripting language
• Extensive validation support for your data
• Easily handle forwarding, redirects, and non-secure connections
• Easily handle SSL(https)
• Role level security
• Container- and application-based authentication
• Built-in URL rewriting for handling cookie-limited browsers
• Multipart forms and file uploads
• Email with attachments and HTML
• Backend direct payment processing
• Support for regular expression matching
• Secure file downloading and uploading
• and tons more (with jWebTk and JPersist)