DDevelopment & Design

Virgo Snaps with Apache Tiles integration

After smoke tests become time to try using Virgo Snaps in more practical way. In modular application it will be useful to run it with templating framework. According to animal-menu-bar sample it will be better if developer of snap will not know anything about layout of host application and snippets like:

<jsp:include page="/../top.jsp"/>
(...)
<jsp:include page="/../bottom.jsp"/>

will be not necessary to put in snap pages. So lets modify a bit hosts jsps. Template page could look similar to old index.jsp:

<%@ taglib prefix="tiles" uri="http://tiles.apache.org/tags-tiles" %>
<jsp:include page="top.jsp"/>

<tiles:insertAttribute name="body" />

<jsp:include page="bottom.jsp"/>

Now index.jsp should not have includes:

 <p>
 The Snap Menu Bar sample is intended to showcase the ability to dynamically change the content of a menu bar using snaps. Each
 of the snaps that might be displayed in the menu bar includes a top and bottom JSP page and inherits it's styling from the host
 bundle.  Therefore, the snap bundle is only responsible for showing a small subset of content.
 </p>

Template definition should have one template without any attributes (it will be added dynamicly):

<tiles-definitions>
    <definition name="defaultTemplate" template="/template.jsp">
    </definition>
</tiles-definitions>

To dynamic adding this definitions we must implement our TilesView. I’ve used one which is a part of parancoe – Open Source Java Web Framework available on Google Code: http://code.google.com/p/parancoe/source/browse/plugins/parancoe-plugin-tiles/src/main/java/org/parancoe/plugin/tiles/CheapTilesView.java?r=f42be9c3c8e2df436d4970cfdaea1aff73d9cfdb and modify it a bit for our purposes. Most interesting part is:

    protected void renderMergedOutputModel(Map model, HttpServletRequest request,
            HttpServletResponse response)
            throws Exception {

        try {
            super.renderMergedOutputModel(model, request, response);
        } catch (TilesException te) {
            lazyRegisterThanRender(request, response);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void lazyRegisterThanRender(HttpServletRequest request, HttpServletResponse response) throws IllegalStateException {
        ServletContext servletContext = getServletContext();
        MutableTilesContainer container = (MutableTilesContainer)
                ServletUtil.getContainer(servletContext);;
        Definition definition = new Definition();

        String[] arr = parsePath(getUrl());
        String subContextPart = arr[0];
        String mainUrlPart    = arr[1];

        definition.setName(getUrl());
        definition.setExtends((String) getAttribute(KEY_DEFAULT_TEMPLATE,
                DEFAULT_DEFAULT_TEMPLATE));
        String attributeList = (String) getAttribute(KEY_DEFAULT_ATTRIBUTES,
                DEFAULT_DEFAULT_ATTRIBUTES);

        String[] attributes = attributeList.split(",");
        if (attributes.length == 1) {
            addAttributeWithPathValueToDefinition(attributes[0], subContextPart, mainUrlPart, definition);
        } else {
            for (String attribute : attributes) {
                addAttributeWithPathValueToDefinition(attributes[0], subContextPart, mainUrlPart + "_" + attribute, definition);
            }
        }

        container.register(definition, request, response);
        container.render(getUrl(), new Object[]{request, response});
    }

How can we see here, lazyRegisterThanRender will be invoked if Tiles will have problems in our case in resolving view name. This method registering new template which extends default one. It also adds attributes taking its values from view name. parsePath parsing path in form: view@snap or only: view:

private String[] parsePath(String path) {
        String[] arr = new String[] {"", ""};
        int indexOfAt = path.indexOf('@');
        if (indexOfAt > 0) {
            arr[0] = '/' + path.substring(indexOfAt+1, path.length());
            arr[1] = path.substring(0, indexOfAt);
        } else {
            arr[1] = path;
        }
        return arr;
    }

In our case will be only body attribute.

To use Tiles we should define tilesConfigurer in spring context. But before this we must declare DispatcherServlet in web.xml which will past requests to our controllers in web.xml:

<servlet>
    <servlet-name>snap</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>snap</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

After this simply adding WEB-INF/snap-servlet.xml context of application will be read:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd"
        default-autowire="byName">

    <bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
        <property name="definitions">
            <list>
                <value>/WEB-INF/tiles.xml</value>
            </list>
        </property>
        <property name="useMutableTilesContainer" value="true"/>
    </bean>

    <bean id="tilesViewResolver" class="org.springframework.web.servlet.view.tiles2.TilesViewResolver">
        <property name="attributesMap">
            <map>
                <entry key="CheapTilesView.DEFAULT_TEMPLATE" value="defaultTemplate"/>
                <entry key="CheapTilesView.DEFAULT_ATTRIBUTES" value="body"/>
            </map>
        </property>
        <property name="viewClass" value="CheapTilesView"/>
    </bean>

    <bean class="MainController"/>

</beans>

After this, we must to add templates definitions: lib/tiles-jsp.tld and few entries in template.mf:

Manifest-Version: 1
Bundle-SymbolicName: animal.menu.bar
Bundle-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Multiple Styles Host
Web-ContextPath: /animal-menu-bar
Import-Library:
 org.springframework.spring;version="[3.0,3.1)"
Import-Bundle:
 com.springsource.org.apache.taglibs.standard;version="[1.1.2,1.3)",
 com.springsource.javax.servlet.jsp.jstl;version="[1.1.2, 1.1.3)",
 org.eclipse.virgo.snaps.api;version="[1.0,2.0)",
 com.springsource.org.apache.tiles;version="2.1.3",
 org.apache.tiles.core;version="2.1.3",
 org.apache.tiles.servlet;version="2.1.3",
 org.apache.tiles.jsp;version="2.1.3"
Import-Package:
 org.eclipse.virgo.snaps.core;version="[1.0,2.0)",
 javax.servlet;version="2.5",
 javax.servlet.http;version="2.5",
 javax.servlet.jsp;version="2.1",
 org.tuckey.web.filters.urlrewrite;version="[3.1.0,3.1.0]",
 org.springframework.js.resource;version="[2.0,2.1)",
 org.springframework.stereotype;version="[3.0,3.1)",
 org.springframework.web.bind.annotation;version="[3.0,3.1)",
 org.springframework.web.servlet;version="[3.0,3.1)",
 org.springframework.web.servlet.view.tiles2;version="[3.0,3.1)",
 org.apache.tiles;version="2.1.3",
 org.apache.tiles.context;version="2.1.3",
 org.apache.tiles.impl;version="2.1.3",
 org.apache.tiles.jsp.context;version="2.1.3",
 org.apache.tiles.mgmt;version="2.1.3",
 org.apache.tiles.renderer.impl;version="2.1.3",
 org.apache.tiles.servlet.context;version="2.1.3"

Our MainController will look like:

@Controller
public class MainController {
    @RequestMapping("/")
    public String rootHandler() {
        return "index";
    }
    @RequestMapping("/index.htm")
    public String snapHandler(@RequestParam("snap") String snap) {
        return "index@" + snap;
    }
}

So we must change top.jsp in host application:

                <snaps:snaps var="snaps">
                    <c:forEach var="snap" items="${snaps}">
                        <li><a href="<c:url value="index.htm?snap=${snap.properties['link.path']}"/>">
                            ${snap.properties['link.text']}</a>
                        </li>
                    </c:forEach>
                </snaps:snaps>

And also in snap.properties of both snaps link.path so it should be equals to snap subcontext (e.g. cat, dog).

After all of this we will have some troubles with resources handling so will be necessary to add urlrewrite filters like it was writed on Rob’s blog about Spring Slices – precursor of Snaps:

Our repository/usr should have:

commons-beanutils-1.8.0.jar
commons-digester-1.8.1.jar
com.springsource.org.apache.commons.collections-3.2.1.jar
com.springsource.org.apache.tiles-2.1.3.jar
com.springsource.org.tuckey.web.filters.urlrewrite-3.1.0.jar
org.eclipse.virgo.snaps.api.jar
org.eclipse.virgo.snaps.core.jar
tiles-core-2.1.3.jar
tiles-jsp-2.1.3.jar
tiles-servlet-2.1.3.jar

which we can copy from maven repository.

Patch with these changes is available on github

— Previous article

<!--:en-->Few thoughts on Crockford's "JavaScript: The Good Parts"<!--:-->

Next article —

<!--:en-->TouK on GitHub Part 1<!--:-->

You May Also Like
DDevelopment & Design

JBoss Envers and Spring transaction managers

I've stumbled upon a bug with my configuration for JBoss Envers today, despite having integration tests all over the application. I have to admit, it casted a dark shadow of doubt about the value of all the tests for a moment. I've been practicing TDD since 2005, and frankly speaking, I should have been smarter than that.

My fault was simple. I've started using Envers the right way, with exploratory tests and a prototype. Then I've deleted the prototype and created some integration tests using in-memory H2 that looked more or less like this example:

@Test
public void savingAndUpdatingPersonShouldCreateTwoHistoricalVersions() {
    //given
    Person person = createAndSavePerson();
    String oldFirstName = person.getFirstName();
    String newFirstName = oldFirstName + "NEW";

    //when
    updatePersonWithNewName(person, newFirstName);

    //then
    verifyTwoHistoricalVersionsWereSaved(oldFirstName, newFirstName);
}

private Person createAndSavePerson() {
    Transaction transaction = session.beginTransaction();
    Person person = PersonFactory.createPerson();
    session.save(person);
    transaction.commit();
    return person;
}    

private void updatePersonWithNewName(Person person, String newName) {
    Transaction transaction = session.beginTransaction();
    person.setFirstName(newName);
    session.update(person);
    transaction.commit();
}

private void verifyTwoHistoricalVersionsWereSaved(String oldFirstName, String newFirstName) {
    List<Object[]> personRevisions = getPersonRevisions();
    assertEquals(2, personRevisions.size());
    assertEquals(oldFirstName, ((Person)personRevisions.get(0)[0]).getFirstName());
    assertEquals(newFirstName, ((Person)personRevisions.get(1)[0]).getFirstName());
}

private List<Object[]> getPersonRevisions() {
    Transaction transaction = session.beginTransaction();
    AuditReader auditReader = AuditReaderFactory.get(session);
    List<Object[]> personRevisions = auditReader.createQuery()
            .forRevisionsOfEntity(Person.class, false, true)
            .getResultList();
    transaction.commit();
    return personRevisions;
}

Because Envers inserts audit data when the transaction is commited (in a new temporary session), I thought I have to create and commit the transaction manually. And that is true to some point.

My fault was that I didn't have an end-to-end integration/acceptance test, that would call to entry point of the application (in this case a service which is called by GWT via RPC), because then I'd notice, that the Spring @Transactional annotation, and calling transaction.commit() are two, very different things.

Spring @Transactional annotation will use a transaction manager configured for the application. Envers on the other hand is used by subscribing a listener to hibernate's SessionFactory like this:

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >        
...
 <property name="eventListeners">
     <map key-type="java.lang.String" value-type="org.hibernate.event.EventListeners">
         <entry key="post-insert" value-ref="auditEventListener"/>
         <entry key="post-update" value-ref="auditEventListener"/>
         <entry key="post-delete" value-ref="auditEventListener"/>
         <entry key="pre-collection-update" value-ref="auditEventListener"/>
         <entry key="pre-collection-remove" value-ref="auditEventListener"/>
         <entry key="post-collection-recreate" value-ref="auditEventListener"/>
     </map>
 </property>
</bean>

<bean id="auditEventListener" class="org.hibernate.envers.event.AuditEventListener" />

Envers creates and collects something called AuditWorkUnits whenever you update/delete/insert audited entities, but audit tables are not populated until something calls AuditProcess.beforeCompletion, which makes sense. If you are using org.hibernate.transaction.JDBCTransaction manually, this is called on commit() when notifying all subscribed javax.transaction.Synchronization objects (and enver's AuditProcess is one of them).

The problem was, that I used a wrong transaction manager.

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
    <property name="dataSource" ref="dataSource"/>
</bean>

This transaction manager doesn't know anything about hibernate and doesn't use org.hibernate.transaction.JDBCTransaction. While Synchronization is an interface from javax.transaction package, DataSourceTransactionManager doesn't use it (maybe because of simplicity, I didn't dig deep enough in org.springframework.jdbc.datasource), and thus Envers works fine except not pushing the data to the database.

Which is the whole point of using Envers.

Use right tools for the task, they say. The whole problem is solved by using a transaction manager that is well aware of hibernate underneath.

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" >
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

Lesson learned: always make sure your acceptance tests are testing the right thing. If there is a doubt about the value of your tests, you just don't have enough of them,
DDevelopment & Design

EhCache config with BeanUtils

BeanUtils allows you to set Bean properties.If you have configuration stored in a Map it's tempting to use BeanUtils to automagically setup EhCache configuration.Sadly this class has mixed types in setters and getter and thus BeanUtils that use Introsp...
DDevelopment & Design

Confitura 2013 afterthoughts

Confitura, the biggest free-of-charge Java conference in Europe, took place on the 6th of July in Warsaw. TouK's presence was heavy, with 5 separate talks, all chosen in call for papers, no sponsored bullshit. We were sponsoring deck chairs during the...Confitura, the biggest free-of-charge Java conference in Europe, took place on the 6th of July in Warsaw. TouK's presence was heavy, with 5 separate talks, all chosen in call for papers, no sponsored bullshit. We were sponsoring deck chairs during the...