Now we will improve our application by exploring a bit the templating engine. We will show a quick overview of Juzu templating system. Templates are essentially made of static part (usually markup) and dynamic parts. In this section we will focus on explaining the use of dynamic expression in a template.

The application shows how a view can provide variable input for a dynamic template with parameters. Our application has a view controller and a template, but now the template contains the ${ } expression that makes it dynamic.

The weather temperature in ${location} is ${temperature} degrees.

Like before the template is used in the view controller but now we use a Map containing the location and temperature parameters.

  @View
  public void index() {
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("location", "Marseille");
    parameters.put("temperature", "20");
    index.render(parameters);
  }

During the template rendering, the location and temperature expressions are resolved to the value provided by the view controller. When a template is rendered, an optional map can be provided, this map will be available during the rendering of the template for resolving expression.

The next step is to make our application obtain real data instead of the hardcoded values we used in the previous section. For this matter we use a remote service that we encapsulate into the WeatherService.

public class WeatherService {

  public String getTemperature(String location) {
    return getTemperature(location, "c");
  }

  public String getTemperature(String location, String grade) {
    try {
      XPath xpath = XPathFactory.newInstance().newXPath();
      XPathExpression expr = xpath.compile("//temp_" + grade + "/@data");
      String url = "http://www.google.com/ig/api?weather=" + location;
      InputSource src = new InputSource(url);
      src.setEncoding("ISO-8859-1");
      return expr.evaluate(src);
    }
    catch (XPathExpressionException e) {
      return "unavailable";
    }
  }
}

Juzu uses dependency injection to interact with a service layer. The JSR-330, also knowns as @Inject, defines an API for dependency injection. The WeatherService is injected in the controller with the weatherService field annotated with the @Inject annotation:

  @Inject
  WeatherService weatherService;

This service is then simply used into our controller index() method:

  @View
  public void index() {
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("location", "Marseille");
    parameters.put("temperature", weatherService.getTemperature("marseille"));
    index.render(parameters);
  }

As we can see, Juzu relies on the portable @Inject annotation to declare sinjections. Injection is performed by the dependency injection container. At the moment the following containers are supported:

There is a preliminary support for Google Guice 3.0, but it is not yet available. In the future more container support could be achieved.

By default it uses the Weld container, if you want instead to use Spring container instead the configuration is done by a portlet init param defined in the deployment descriptor of the portlet:

<init-param>
  <name>juzu.inject</name>
  <value>spring</value>
</init-param>

In the case of Spring, the file spring.xml file is needed, it contains the service declarations for the Spring container.

Juzu provides more advanced dependency injection, in particular it uses the Qualifier and Scope features defined by the JSR-330 specification that will be studied later.

Until now we have seen a basic view controller, in this section we will study more in depth view controllers. A view controller is invoked by Juzu when the application needs to be rendered, which can happen anytime during the lifecycle of an application.

This version has still the index() view controller, but now it has also an overloaded index(String location) method that accept a location argument as a view parameter.

  @View
  public void index(String location) {
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("location", location);
    parameters.put("temperature", weatherService.getTemperature("marseille"));
    index.render(parameters);
  }

View parameters are bound to the current navigation of the application and their value are managed by the framework. At this point it is normal to wonder how a view parameter value can change. Let's have a closer look at the index.gtmpl application template.

The weather temperature in ${location} is ${temperature} degrees.
<a href="@{index(location = 'marseille')}">Marseille</a>
<a href="@{index(location = 'paris')}">Paris</a>

The template now has two links that change the view parameters when they are processed. The links are created by a special syntax that references the view method, for instance the script fragment @{index(location = 'paris')} generates an url that updates the location view parameter to the paris value when it is processed.

The initial controller method index() is still there but now it simply invokes the index(String location) controller with a predefined value.

  @View
  public void index() {
    index("marseille");
  }

We could't close this section without talking a bit about safe urls. Juzu is deeply integrated at the heart of the Java compiler and performs many checks to detect applications bugs during the application compilation. Among those checks, templates are validated and the url syntax @{ } is checked against the application controllers. In fact Juzu will resolve an url syntax until it finds one controller that resolves the specified name and parameters. If not Juzu will make the compilation fail and give detailled information about the error. This kind of feature makes Juzu really unique among all other web frameworks, we will see some other later.

Now it's time to introduce action controllers, actions are method annotated by the @Action annotation. Unlike views, actions are only called when an action url is processed by the portal, whereas a view controller method can be invoked any time by the portal.

The role of an action controller is to process actions parameters. Each parameter of an action controller method is mapped to the incoming request processed by the portal, such parameters can be encoded directly in the URL or be present in the form that triggers the action.

The weather temperature in ${location} is ${temperature} degrees.

<ul><% locations.each() { location -> %>
<li><a href="@{index(location = location)}">${location}</a></li>
<% } %>
</ul>

<form action="@{add()}" method="post">
   <input type="text" name="location" value=""/>
   <input type="submit"/>
</form>

In our example, we use a form which contains the the #location# action parameters. In order to create an action url we use the same syntax shown for view url @{add()} but this time we don't need to set any parameter, instead the form parameters will be used when the form is submitted. However this is not mandatory and instead we could have url parameters such as @{add(location = 'washington'}, such syntax is valid specially when it is used without a form. Obviously there is the possibility to mix form and action parameters.

When the url is processed, the following action controller method will be invoked:

  @Action
  public Response add(String location) {
    locations.add(location);
    return Weather_.index(location);
  }

The method process the location parameter and add it to the locations set. After this the portal will proceed to the page rendering phase and will call the index() method to refresh the application.

We have seen previously how render templates from a controller by passing them parameters. Templates use ${ } expressions that often refers to parameters passed by the controller when it renders the template. For this purpose we used an HashMap in which we put the various parameters that the template will use during rendering.

This syntax is a generic way to do by using an untyped syntax, indeed if a template parameter name changes the controller will continue to compile because of the generic parameter map. To improve this situation, parameters can be declared thanks to a param tag inside the template:

#{param name=location/}
#{param name=temperature/}
#{param name=locations/}

The weather temperature in ${location} is ${temperature} degrees.

<ul><% locations.each() { location -> %>
<li><a href="@{index(location = location)}">${location}</a></li>
<% } %>
</ul>

<form action="@{add()}" method="post">
   <input type="text" name="location" value=""/>
   <input type="submit"/>
</form>

For instance the location parameter is declared by the #{param name=location/} tag. During the Java compilation, Juzu leverage those parameter declarations to provide a more convenient way to render a template.

Indeed the tight integration with the Java compiler allows Juzu to generate a template class for each template of the application, such template class inherits the Template class and adds specific methods for passing parameters to a template in a safe manner.

  @View
  public void index(String location) {
    index.
      with().
      location(location).
      temperature(weatherService.getTemperature(location)).
      locations(locations).
      render();
  }

As we can see, the HashMap is not used anymore and now we use a type safe and compact expression for rendering the template. Each declared parameter generates a method named by the parameter name, for the location parameter, we do have now a location(String location) method that can be used. To make the syntax fluent, the parameter methods can be chained, finally the render() method is invoked to render the template, however it does not require any parameter since all parameters where passed thanks to the parameter methods.

The Java name of the generated template class is the name of the template in the templates package of the application. In our case we do obtain the examples.tutorial.weather6.templates.index class name. It is very easy to use our subclass by injecting the template subclass instead of the generic Template class.

  @Inject
  @Path("index.gtmpl")
  examples.tutorial.weather6.templates.index index;

Of course it is possible to import this value and use directly the index class name. We used directly the full qualified name of the class for the sake of the clarity.

A portlet provides a PortletPreferences object for loading and saveing user preferences, it is a collection of key and values of type string, very much like a map. Juzu does not wrap the preferences object, instead it can be injected via the @Inject annotation:

  @Inject
  PortletPreferences preferences;

The preferences object is available during the various phases of the application and can be used to retrieve and store user preferences, but keep in mind that storing preferences can only be done an action phase.

  @View
  public void index(String location) {
    String grade = preferences.getValue("grade", "c");
    index.
      with().
      location(location).
      temperature(weatherService.getTemperature(location, grade)).
      grade(grade).
      locations(locations).
      render();
  }

#{param name=location/}
#{param name=temperature/}
#{param name=locations/}
#{param name=grade/}

<form style="float:right" action="@{updateGrade()}" method="post">
    <select name="grade" onChange="javascript:this.form.submit();">
        <option value="c" <%=grade=='c'?'selected':''%>>celsius</option>
        <option value="f" <%=grade=='f'?'selected':''%>>fahrenheit</option>
    </select>
</form>

The weather temperature in ${location} is ${temperature} degrees.

<ul><% locations.each() { location -> %>
    <li><a href="@{index(location = location)}">${location}</a></li>
    <% } %>
</ul>

<form action="@{add()}" method="post">
    <input type="text" name="location" value=""/>
    <input type="submit"/>
</form>

  @Action
  public void updateGrade(String grade) throws java.io.IOException,
    javax.portlet.PortletException {
    preferences.setValue("grade", grade);
    preferences.store();
  }

Our application is almost complete, in this section we will work on the look and feel to make the application appealing. We will use the famous Twitter Bootstrap framework and show how it integrates well in Juzu applications.

/*!
 * Bootstrap v2.0.3
 *
 * Copyright 2012 Twitter, Inc
 * Licensed under the Apache License v2.0
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Designed and built with all the love in the world @twitter by @mdo and @fat.
 */

// CSS Reset
@import "reset.less";

// Core variables and mixins
@import "variables.less"; // Modify this for custom colors, font-sizes, etc
@import "mixins.less";

// Grid system and page structure
@import "scaffolding.less";

// Base CSS
@import "type.less";
@import "forms.less";

// Components: common
@import "component-animations.less";

// Components: Buttons & Alerts
@import "buttons.less";
@import "button-groups.less";

// Components: Misc
@import "accordion.less";

div.red { color:red; }

.tutorial div.red { color:red; }

.tutorial {
  div.red { color:red; }
}

Plugins in action

Juzu can be extended with plugins, in this section we will use two of them

• The Less plugin compiles less files into css files

• The Asset plugin inject asset such as stylesheet or javascript in the application page

Less compilation

Juzu provides native support for the Less language via the Less plugin and the @Less annotation. It allows a set of less files to be transformed into the corresponding css files during the java compilation, achieving two important steps during the compilation phase:

• The less files are transformed into ready to use css files

• It ensures a maximum of safety: the Less parser will report any error in the source

Our first step is to create the examples.tutorial.assets package, we copy the Bootstrap Less files into this package and annotate the examples.tutorial package with the @Less annotation to trigger the compilation of the stylesheet in the assets package:

@Less(value = "bootstrap.less", minify = true)
package examples.tutorial;

import juzu.plugin.less.Less;

This annotation triggers the compilation of the bootstrap.less in the assets package, the minified parameter instruct Less to minify the resulting css.

Injecting CSS

Now that we have worked out the CSS details we need to make our stylesheet available in the application page. The asset plugin will achieve this result for us. This plugin provides declarative configuration for the various assets required by an application. It works both for stylesheets and javascript, in this section we use it for stylesheet:

Example 8.5. Injecting Bootstrap CSS in our application

@Application
@Assets(stylesheets = @Stylesheet(
  src = "/examples/tutorial/assets/bootstrap.css",
  location = AssetLocation.CLASSPATH)
)
package examples.tutorial.weather8;

The usage is fairly straightforward with the @Assets and Stylesheet annotations. We configure the location parameter to be CLASSPATH because the Less plugin created it there.

Bringing CSS to life

After this step we need to modify our application template to use the various styles provided by Bootstrap:

Figure 8.1. The Bootstrapized application

We will not explain that in details, however we will study the important modifications:

Scoping the rules

As seen previously we need to scope our markup with the tutorial class, it is achieved by wrapping our application markup with a div tag:

<div class="tutorial">
  ...
</div>

Accordion

The Bootstrap provides the Collapse component. We will not use the entire Collapse component here but instead reuse the CSS rules to display the available cities:

<div class="accordion-group">
  <div class="accordion-heading"><a class="accordion-toggle" href="@{index(location = current)}">${current}</a></div>
  <div class="accordion-body">
    <div class="accordion-inner">The weather temperature in ${current} is ${temperature}&deg; ${grade.toUpperCase()}.</div>
  </div>
</div>

Temperature selection

The switch between Celsius and Fahrenheit is done thanks to Boostrap button groups and inverse rules:

  <a class="btn <%=grade=='c'?'btn-inverse':''%>"
    href="@{updateGrade(grade='c',location=location)}">C</a>
  <a class="btn <%=grade=='f'?'btn-inverse':''%>"
    href="@{updateGrade(grade='f',location=location)}">F</a>

Adding a city

Finally the form for adding is modified to reuse Bootstrap form support:

<form action="@{add()}" method="post">
  <fieldset>
    <div class="controls">
      <div class="input-append">
         <input class="span2" type="text" size="16"name="location" value=""/>
         <button type="submit" class="btn">Add</button>
      </div>
    </div>
  </fieldset>
</form>

Now that our application look great, we are going to add a final touch to our application and make it more dynamic.

In the previous section we introduced the accordion user interface component, but it was used in a static way. In this section we will make it dynamic and introduce the Ajax plugin.

The accordion component can be combined to the JQuery collapse plugin providing the capability to unfold an item to display the weather of the location. When the item is unfolded an ajax request is performed to the application to retrieve the markup that will be inserted.

@Assets(
   scripts = {
      @Script(
         id = "jquery",  
         src = "jquery-1.7.1.min.js",
         location = AssetLocation.CLASSPATH),
      @Script(
         id = "transition",
         src = "bootstrap-transition.js",  
         location = AssetLocation.CLASSPATH,
         depends = "jquery"),  
      @Script(
         id = "collapse",
         src = "bootstrap-collapse.js",
         location = AssetLocation.CLASSPATH,
         depends = {
            "jquery", // 1
            "transition"}),  
      @Script(
         src = "weather.js",
         location = AssetLocation.CLASSPATH,
         depends = {
            "jquery",   
            "collapse"})  
   },
   stylesheets = @Stylesheet(src = "/examples/tutorial/assets/bootstrap.css", location = AssetLocation.CLASSPATH)
)
package examples.tutorial.weather9;

<div class="accordion-group">
  <div class="accordion-heading">
    <a class="accordion-toggle" href="#${current}" data-parent="${id}" data-toggle="collapse">${current}</a>
  </div>
  <% def expanded = i != index ? 'in' : ''; %>
  <div id="${current}" class="accordion-body collapse ${expanded}">
    <div class="accordion-inner">
    </div>
  </div>
</div>

  @Inject
  @Path("fragment.gtmpl")
  examples.tutorial.weather9.templates.fragment fragment;

  @Ajax
  @Resource
  public void getFragment(String location) {
    String grade = preferences.getValue("grade", "c");
    String temperature = weatherService.getTemperature(location, grade);
    fragment.
      with().
      location(location).
      temperature(weatherService.getTemperature(location, grade)).
      grade(grade).
      render();
  }

#{param name=location/}
#{param name=temperature/}
#{param name=grade/}
The weather temperature in ${location} is ${temperature}°
${grade.toUpperCase()}.

$(function () {

  // Setup an event listener on the .collapse element when it is shown
  $('.collapse').on('show', function () {

    // Get the location attribute from the dom
    var location = $(this).attr("id");

    // Update the .accordion-inner fragment
    $(this).
      closest(".accordion-group").
      find(".accordion-inner").
      each(function () {

      // Load the fragment from the resource controller
      $(this).jzLoad(
        "Weather.getFragment()",
        {"location":location});

    });
  });

  // Setup the collapse component
  $(".collapse").collapse();
});

$(function() {
  //
});

<div class="jz">
  <div data-method-id="Weather.getFragment()## data-url="http://localhost:8080/....."/>
  ...
</div>

We reached the ends our walk through Juzu, now you can learn more and study the Booking application. This application can be found in the package you downloaded in the booking directory.