# Spring JavaScript Quick Reference

## Introduction

Spring Javascript (spring-js) is a lightweight abstraction over common JavaScript toolkits such as Dojo. It aims to provide a common client-side programming model for progressively enhancing a web page with rich widget behavior and Ajax remoting.

Use of the Spring JS API is demonstrated in the the Spring MVC + Web Flow version of the Spring Travel reference application. In addition, the JSF components provided as part of the Spring Faces library build on Spring.js.

## Serving Javascript Resources

Spring JS provides a generic `ResourceServlet` to serve web resources such as JavaScript and CSS files from jar files, as well as the webapp root directory. This servlet provides a convenient way to serve Spring.js files to your pages. To deploy this servlet, declare the following in `web.xml`:

    <!-- Serves static resource content from .jar files such as spring-js.jar -->
    <servlet>
        <servlet-name>Resource Servlet</servlet-name>
        <servlet-class>org.springframework.js.resource.ResourceServlet</servlet-class>
    </servlet>

    <!-- Map all /resources requests to the Resource Servlet for handling -->
    <servlet-mapping>
        <servlet-name>Resource Servlet</servlet-name>
        <url-pattern>/resources/*</url-pattern>
    </servlet-mapping>

## Including Spring Javascript in a Page

Spring JS is designed such that an implementation of its API can be built for any of the popular Javascript toolkits. The initial implementation of Spring.js builds on the Dojo toolkit.

Using Spring Javascript in a page requires including the underlying toolkit as normal, the `Spring.js` base interface file, and the `Spring-(library implementation).js` file for the underlying toolkit. As an example, the following includes obtain the Dojo implementation of Spring.js using the `ResourceServlet`:

    <script type="text/javascript" src="<c:url value="/resources/dojo/dojo.js" />"> </script>
    <script type="text/javascript" src="<c:url value="/resources/spring/Spring.js" />"> </script>
    <script type="text/javascript" src="<c:url value="/resources/spring/Spring-Dojo.js" />"> </script>

When using the widget system of an underlying library, typically you must also include some CSS resources to obtain the desired look and feel. For the booking-mvc reference application, Dojo's `tundra.css` is included:

    <link type="text/css" rel="stylesheet" href="<c:url value="/resources/dijit/themes/tundra/tundra.css" />" />

## Spring Javascript Decorations

A central concept in Spring Javascript is the notion of applying decorations to existing DOM nodes. This technique is used to progressively enhance a web page such that the page will still be functional in a less capable browser. The `addDecoration` method is used to apply decorations.

The following example illustrates enhancing a Spring MVC `<form:input>` tag with rich suggestion behavior:

    <form:input id="searchString" path="searchString"/>
    <script type="text/javascript">
        Spring.addDecoration(new Spring.ElementDecoration({
            elementId: "searchString",
            widgetType: "dijit.form.ValidationTextBox",
            widgetAttrs: { promptMessage : "Search hotels by name, address, city, or zip." }}));
    </script>

The `ElementDecoration` is used to apply rich widget behavior to an existing DOM node. This decoration type does not aim to completely hide the underlying toolkit, so the toolkit's native widget type and attributes are used directly. This approach allows you to use a common decoration model to integrate any widget from the underlying toolkit in a consistent manner. See the `booking-mvc` reference application for more examples of applying decorations to do things from suggestions to client-side validation.

When using the `ElementDecoration` to apply widgets that have rich validation behavior, a common need is to prevent the form from being submitted to the server until validation passes. This can be done with the `ValidateAllDecoration`:

    <input type="submit" id="proceed" name="_eventId_proceed" value="Proceed" />
    <script type="text/javascript">
        Spring.addDecoration(new Spring.ValidateAllDecoration({ elementId:'proceed', event:'onclick' }));
    </script>

This decorates the "Proceed" button with a special onclick event handler that fires the client side validators and does not allow the form to submit until they pass successfully.

An `AjaxEventDecoration` applies a client-side event listener that fires a remote Ajax request to the server. It also auto-registers a callback function to link in the response:

    <a id="prevLink" href="search?searchString=${criteria.searchString}&page=${criteria.page - 1}">Previous</a>
    <script type="text/javascript">
        Spring.addDecoration(new Spring.AjaxEventDecoration({
            elementId: "prevLink",
            event: "onclick",
            params: { fragments: "body" }
        }));
    </script>

This decorates the onclick event of the "Previous Results" link with an Ajax call, passing along a special parameter that specifies the fragment to be re-rendered in the response. Note that this link would still be fully functional if Javascript was unavailable in the client. (See the section on Handling Ajax Requests for details on how this request is handled on the server.)

It is also possible to apply more than one decoration to an element. The following example shows a button being decorated with Ajax and validate-all submit suppression:

    <input type="submit" id="proceed" name="_eventId_proceed" value="Proceed" />
    <script type="text/javascript">
        Spring.addDecoration(new Spring.ValidateAllDecoration({elementId:'proceed', event:'onclick'}));
        Spring.addDecoration(new Spring.AjaxEventDecoration({elementId:'proceed', event:'onclick',formId:'booking', params:{fragments:'messages'}}));
    </script>

It is also possible to apply a decoration to multiple elements in a single statement using Dojo's query API. The following example decorates a set of checkbox elements as Dojo Checkbox widgets:

    <div id="amenities">
    <form:checkbox path="amenities" value="OCEAN_VIEW" label="Ocean View" /></li>
    <form:checkbox path="amenities" value="LATE_CHECKOUT" label="Late Checkout" /></li>
    <form:checkbox path="amenities" value="MINIBAR" label="Minibar" /></li>
    <script type="text/javascript">
        dojo.query("#amenities input[type='checkbox']").forEach(function(element) {
            Spring.addDecoration(new Spring.ElementDecoration({
                elementId: element.id,
                widgetType : "dijit.form.CheckBox",
                widgetAttrs : { checked : element.checked }
            }));
        });
    </script>
    </div>

## Handling Ajax Requests

Spring Javascript's client-side Ajax response handling is built upon the notion of receiving "fragments" back from the server. These fragments are just standard HTML that is meant to replace portions of the existing page. The key piece needed on the server is a way to determine which pieces of a full response need to be pulled out for partial rendering.

In order to be able to render partial fragments of a full response, the full response must be built using a templating technology that allows the use of composition for constructing the response, and for the member parts of the composition to be referenced and rendered individually. Spring Javascript provides some simple Spring MVC extensions that make use of Tiles to achieve this. The same technique could theoretically be used with any templating system supporting composition.

Spring Javascript's Ajax remoting functionality is built upon the notion that the core handling code for an Ajax request should not differ from a standard browser request, thus no special knowledge of an Ajax request is needed directly in the code and the same hanlder can be used for both styles of request.

### Providing a Library-Specific AjaxHandler

The key interface for integrating various Ajax libraries with the Ajax-aware behavior of Web Flow (such as not redirecting for a partial page update) is `org.springframework.js.AjaxHandler`. A `SpringJavascriptAjaxHandler` is configured by default that is able to detect an Ajax request submitted via the Spring JS client-side API and can respond appropriately in the case where a redirect is required. In order to integrate a different Ajax library (be it a pure JavaScript library, or a higher-level abstraction such as an Ajax-capable JSF component library), a custom `AjaxHandler` can be injected into the `FlowHandlerAdapter` or `FlowController`.

### Handling Ajax Requests with Spring MVC Controllers

In order to handle Ajax requests with Spring MVC controllers, all that is needed is the configuration of the provided Spring MVC extensions in your Spring application context for rendering the partial response (note that these extensions require the use of Tiles for templating):

    <bean id="tilesViewResolver" class="org.springframework.js.ajax.AjaxUrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.webflow.mvc.view.FlowAjaxTilesView"/>
    </bean>

This configures the `AjaxUrlBasedViewResolver` which in turn interprets Ajax requests and creates `FlowAjaxTilesView` objects to handle rendering of the appropriate fragments. Note that `FlowAjaxTilesView` is capable of handling the rendering for both Web Flow and pure Spring MVC requests. The fragments correspond to individual attributes of a Tiles view definition. For example, take the following Tiles view definition:

    <definition name="hotels/index" extends="standardLayout">
        <put-attribute name="body" value="index.body" />
    </definition>

    <definition name="index.body" template="/WEB-INF/hotels/index.jsp">
        <put-attribute name="hotelSearchForm" value="/WEB-INF/hotels/hotelSearchForm.jsp" />
        <put-attribute name="bookingsTable" value="/WEB-INF/hotels/bookingsTable.jsp" />
    </definition>

An Ajax request could specify the "body", "hotelSearchForm" or "bookingsTable" to be rendered as fragments in the request.

### Handling Ajax Requests with Spring MVC + Spring Web Flow

Spring Web Flow handles the optional rendering of fragments directly in the flow definition language through use of the `render` element. The benefit of this approach is that the selection of fragments is completely decoupled from client-side code, such that no special parameters need to be passed with the request the way they currently must be with the pure Spring MVC controller approach. For example, if you wanted to render the "hotelSearchForm" fragment from the previous example Tiles view into a rich Javascript popup:

    <view-state id="changeSearchCriteria" view="enterSearchCriteria.xhtml" popup="true">
        <on-entry>
            <render fragments="hotelSearchForm" />
        </on-entry>
        <transition on="search" to="reviewHotels">
            <evaluate expression="searchCriteria.resetPage()"/>
        </transition>
    </view-state>