Initially I was going to call the render(…) method of MappingJacksonJsonView but that didn’t work because the content-type had already been set to application/json. The solution I came up with was to duplicate some of the code (ugh) inside MappingJacksonJsonView to get the JSON as a string and to then write that to the response:

@RequestMapping
public void processFileUpload(HttpServletResponse response, Model model, ...) {

    ...

    //Set the content-type and charset of the response
    response.setContentType("text/plain");
    response.setCharacterEncoding("UTF-8");

    //I need to use another OutputStream here; I cannot use the response's OutputStream because that will cause errors
    //later on when the JSP needs to render its content (recall that getOutputStream() can only be called exactly once
    //on a response). Therefore I'm writing the data to a ByteArrayOutputStream and then writing the byte array from
    //the ByteArrayOutputStream to the response manually.

    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ObjectMapper objectMapper = new ObjectMapper();
    JsonGenerator generator = objectMapper.getJsonFactory().createJsonGenerator(byteArrayOutputStream, JsonEncoding.UTF8);

    //Before I can convert the data into JSON, I will need to filter some attributes out of the model (namely BindingResult)
    Map<String, Object> result = new HashMap<String, Object>();

    for(Map.Entry<String, Object> entry : model.asMap().entrySet()) {
        if(!(entry.getValue() instanceof BindingResult)) {
            result.put(entry.getKey(), entry.getValue());
        }
    }

    objectMapper.writeValue(generator, result);
    response.getWriter().write(new String(byteArrayOutputStream.toByteArray(), "UTF8"));
}

This still seems a little hacky to me. A possible improvement is to annotate the action with @ResponseBody and return the JSON as a string without involving the response at all. If anyone has a better solution, I’m all ears!

$str .= '<img src="'.site_url('?ak_action=api_record_view&#38;id='.$post->ID.'&#38;type=feed').'" alt="" />';

Although I pulled my hair out for an hour or two (I was getting a 404 when hitting my controller with with a .jsonp extension; I’ll explain why, later), the resulting solution is actually pretty simple. First, you need to extend MappingJacksonJsonView to create your own view. Since MappingJacksonJsonView already handles the creation of JSON, all we need to do is pad it with our callback. The way to do this is to override the MappingJacksonJsonView#render(Map model, HttpServletRequest request, HttpServletResponse response) method (This method is actually defined in AbstractView, a Spring-provided abstract class that you can override in your own view). The full source is below:

package net.vivin.mvc.spring.view.jsonp;

import org.springframework.web.servlet.view.json.MappingJacksonJsonView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

public class MappingJacksonJsonpView extends MappingJacksonJsonView {

	/**
	 * Default content type. Overridable as bean property.
	 */
	public static final String DEFAULT_CONTENT_TYPE = "application/javascript";

    @Override
    public String getContentType() {
        return DEFAULT_CONTENT_TYPE;
    }

 	/**
	 * Prepares the view given the specified model, merging it with static
	 * attributes and a RequestContext attribute, if necessary.
	 * Delegates to renderMergedOutputModel for the actual rendering.
	 * @see #renderMergedOutputModel
	 */
    @Override
	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

        if("GET".equals(request.getMethod().toUpperCase())) {
            @SuppressWarnings("unchecked")
            Map<String, String[]> params = request.getParameterMap();

            if(params.containsKey("callback")) {
                response.getOutputStream().write(new String(params.get("callback")[0] + "(").getBytes());
                super.render(model, request, response);
                response.getOutputStream().write(new String(");").getBytes());
                response.setContentType("application/javascript");
            }

            else {
                super.render(model, request, response);
            }
        }

        else {
            super.render(model, request, response);
        }
    }
}

The DEFAULT_CONTENT_TYPE public static property and the getContentType() method are important. Spring uses this method (among other things) to find the best candidate view. I spent at least an hour trying to figure out why I was getting 404′s. It was because I hadn’t overridden the property and the accessor to return the correct content-type. Going back to the render method itself, you can see that it’s pretty simple. First I make sure that the request method is GET. Then I get the request parameter-map and check for the callback parameter. If this parameter exists, I write out the name of the callback with an open parenthesis. Then I call the parent class’s render method. This method belongs to MappingJacksonJsonView and will write out JSON to the response. Finally, I write out a closing parenthesis and a semicolon to the response and set the content type to application/javascript. So as you can see, I’ve converted JSON into JSONP.

The next thing you need to do is include an entry for your new view in the springmvc-servlet.xml file. This part also took a little work. I wasn’t sure how to include my new view within the ContentNegotiatingViewResolver bean. But this post proved to be remarkably helpful. The post actually talks about returning XML or JSON (based on the extension), but I was able to adapt it to return JSON or JSON. Here’s what it looks like:

    <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        <property name="favorPathExtension" value="true"/>
        <property name="mediaTypes">
            <map>
                <entry key="json" value="application/json"/>
                <entry key="jsonp" value="application/javascript"/>
            </map>
        </property>
        <property name="defaultViews">
            <list>
                <bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView"/>
                <bean class="net.vivin.mvc.spring.view.jsonp.MappingJacksonJsonpView"/>
            </list>
        </property>
    </bean>

If you notice, the value property for jsonp has been set to application/javascript. Spring uses this value and checks it against the view class to figure out the best candidate view. If you didn’t override the DEFAULT_CONTENT_TYPE property and the associated getter, you would get a 404.

Finally, you need a url-pattern entry under servlet-mapping in your web.xml file so that the new .jsonp extension is recognized:

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.json</url-pattern>
        <url-pattern>*.jsonp</url-pattern>
        ...
    </servlet-mapping>

That’s pretty much it. With this code in place, you can hit your controller with http://my.domain.com/controllerName/actionName.jsonp?callback=myCallback and you’ll get your data back as JSONP! I thought this solution was pretty simple and a little less invasive than creating a filter. Comments/suggestions/criticisms for improvement are welcome!

The source for the integration is also hosted on GitHub. My approach towards translating validation constraints from the server-side to the client-side was two-fold: gather validation constraints from the object and represent it in a canonical form. Using the canonical form, generate Javascript code that uses Regula for validation. To do this, I created a service that examines a domain object and gathers all information regarding its properties and validation constraints. The service returns this information in a canonical form, that I then inserted into the model. On the client-side, I had a tag that used the canonical form and outputted Javascript that uses the Regula framework. Initially, I was calling the service explicitly from an action in the controller. Later, in an effort to make the integration less-invasive and more seamless, I used an aspect-oriented approach with interceptors. In fact, that’s where I’d like to start.

I created an annotation called @ValidateClientSide that marks a domain object as requiring client-side validation. Then, I created an interceptor called ClientSideValidationInterceptor that will call the validation service and gather validation information:

If you’re trying to distribute tag files in a JAR, you need to put them under /META-INF/tags. You then need to create a TLD file that you also put under /META-INF/tags. If you have tags or functions that you created in Java, and want to distribute them alongside the tag files, you need to reference them in the TLD and package them in the same JAR (goes without saying).

If you want to do the same thing in maven, the location for the tag files and the tld file is different; you need to put them in src/main/resources/META-INF/tags. Then you can run mvn package and maven will create a JAR with your tags.

My directory structure in my maven project looks like this:

src
`-- main
    |-- java
    |   `-- net
    |       `-- vivin
    |           `-- regula
    |               `-- validation
    |                   `-- util
    |                       `-- TagStringUtils.java
    `-- resources
        `-- META-INF
            `-- tags
                |-- generate-validation.tag
                `-- regula-spring.tld

And my TLD file looks like this:

<taglib>
 <tlib-version>1.0</tlib-version>
 <short-name>regula-spring</short-name>
 <uri>http://regula-spring</uri>
 <jsp-version>2.0</jsp-version>

 <tag-file>
   <name>generate-validation</name>
   <path>/META-INF/tags/generate-validation.tag</path>
 </tag-file>

 <function>
   <name>matches</name>
   <function-class>net.vivin.regula.validation.util.TagStringUtils</function-class>
   <function-signature>boolean matches(java.lang.String, java.lang.String, java.lang.String)</function-signature>
 </function>

 <function>
   <name>replaceUsingRegex</name>
   <function-class>net.vivin.regula.validation.util.TagStringUtils</function-class>
   <function-signature>java.lang.String replaceUsingRegex(java.lang.String, java.lang.String, java.lang.String, java.lang.String)</function-signature>
 </function>
</taglib>

<input id = "myInput"
         type = "text"
         data-constraints = '@NotEmpty @IsNumeric @Between(min=1, max=5)'>

That bit of code describes a text box which cannot be empty, and which expects a numeric value between 1 and 5. With this basic design in mind, I started working on my framework. It took me about a week of on-and-off work (maybe 3 days actual work) but I’ve come up with something that is, in my humble opinion, a flexible and easy to use framework. I plan to document the use of this library/framework more thoroughly, but this post should serve as a gentle introduction to the framework and its features.

In Regula (which, by the way, means “rule” in Latin) form elements (input elements or even the form elements) can have constraints attached to them in a similar fashion to the example I described earlier. There is a small difference, however:

<input id = "myInput"
         class = "regula-validation"
         type = "text"
         data-constraints = '@NotEmpty @IsNumeric @Between(min=1, max=5)'>

As you can see, I use a class name of regula-validation which tells the framework that this input element has constraints attached to it. The reason I did this was for efficiency reasons. It’s much more efficient to grab all elements that have a class name of regula-validation than walking the whole document tree to search for nodes that have a data-constraints attribute.

After you annotate the input elements with their constraints, you’re halfway there already! All you have to do after that is add a script tag for the framework:

  <script type = "text/javascript" src="regula.js"></script>

And then add the necessary Javascript to validate the form (example uses jQuery):

jQuery(document).ready(function() {
    // must call this first. The best place would be in an
    // onload handler. This function looks for elements with
    // a class name of "regula-validation" and binds the
    // appropriate constraints to the elements
    regula.bind(); 

    jQuery("#myForm").submit(function() {
        // this functions performs the actual validation
        var validationResults = regula.validate();

        for(var index in validationResults) {
             var validationResult = validationResults[index];
             alert(validationResult.message);
        }
    });
});

That’s pretty much all there is to it. More advanced uses of the framework don’t deviate that much from this pattern. Compared to other form-validation frameworks (that I’ve seen), validation will not stop on the first failing element. The validate function runs through every input element and validates it against the constraints bound to that element, and returns an array of “validation results”. Each “validation result” element in the array has the following properties:

• constraintName – the name of the failing constraint
• custom – a flag that says whether this is a custom constraint or not
• constraintParameters – An array of objects that represents the parameters passed to this constraint (defined in the HTML. For example @Max(max=5), where you have a parameter who’s name is max and who’s value is 5. There’s a little more to this, but like I said, this is supposed to be a gentle introduction )
• receivedParameters – A hash (organized such that the name of the parameter is the key, and the value is well, the value) of parameters that the validator function received (helpful when you have a custom validator).
• failingElements – An array containing references to the actual input element or elements (in the case of form-specific constraints) that failed the constraint.
• message – The error message.

While writing my own custom tag, I noticed that although instanceof is a reserved word in the JSTL EL (expression language), it is not supported as an operator. The reason I wanted to use the instanceof operator is that I have an attribute that could either be a List or a Map and depending on the type, I wanted to do different things.

Another thing I was trying to do, was to inspect the incoming object to see if it had a certain property (reflection). JSTL uses reflection so that you can access the properties of an object via dot notation, if they follow the JavaBean naming-convention. However, there was no way for me to see if an object had a certain property. To solve both these problems, I wrote my own JSTL functions.

The first function I wrote was one that performed the instanceof operation. I created a class called TagUtils that contained static methods that returned primitive types (like boolean, String, or Integer). instanceof presents a special challenge because you can’t have the second parameter be dynamic. For example, assuming that you have an object named acura that’s an instance of the class Car and a String named className that holds the value “Car“, you can’t do acura instanceof className. You have to use reflection and create a Class object using the forName static method and then check to see if acura is an instance by using the isInstance method.

The second function I wrote is the hasProperty function which uses reflection to check whether the supplied object has a particular property. To be precise, I don’t explicitly check for the existence of the object directly. Rather, I check and see if there is a getter for that property. For example, if the property is called firstName, then there should be a getter called getFirstName().

The code for the functions looks like this:

package util.tag;

public class TagUtils {

    //Checks to see if Object 'o' is an instance of the class in the string "className"
    public static boolean instanceOf(Object o, String className) {
        boolean returnValue;

        try {
            returnValue = Class.forName(className).isInstance(o);
        }

        catch(ClassNotFoundException e) {
            returnValue = false;
        }

        return returnValue;
    }

    //Checks to see if Object 'o' has a property specified in "propertyName"
    public static boolean hasProperty(Object o, String propertyName) {
        boolean methodFound = false;
        int i = 0;

        Class myClass = o.getClass();
        String methodName = "get" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
        Method[] methods = myClass.getMethods();

        while(i < methods.length && !methodFound) {
            methodFound = methods[i].getName().compareTo(methodName) == 0;
            i++;
        }

        return methodFound;
    }
}

For the hasProperty function, you can see that I used the getMethod method. The second argument is an array of parameter types. Since the getter accepts no parameters, we pass in an empty array (of type Class).

Using exceptions in business logic is really bad, because it slows down the JVM. So the rendering will also become really slow if there are a lot of exceptions being thrown. To fix this problem, I used the getMethods method, which returns an array of Method objects. I then search the array to see if the getter I want, exists.

After you create your functions, you have to put them in a tld file. I created a one called tagutils.tld that I put in WEB-INF:

<?xml version="1.0" encoding="UTF-8"?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
    version="2.1">
    <tlib-version>1.0</tlib-version>
    <short-name>function</short-name>
    <uri>http://tagutils</uri>
    <function>
        <name>instanceOf</name>
        <function-class>util.tag.TagUtils</function-class>
        <function-signature>boolean instanceOf(java.lang.Object, java.lang.String)</function-signature>
    </function>
    <function>
        <name>hasProperty</name>
        <function-class>util.tag.TagUtils</function-class>
        <function-signature>boolean hasProperty(java.lang.Object, java.lang.String)</function-signature>
    </function>
</taglib>

Once you create that file, you can use your new functions in your JSP files. To test the hasProperty function, I created a simple class called Person:

package domain;

public class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String toString() {
        return firstName + " " + lastName;
    }
}

Now I put it all together:

<%@ taglib prefix="function" uri="http://tagutils"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ page import="java.util.Map" %>
<%@ page import="java.util.LinkedHashMap" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="domain.Person" %>
<%
    Map<String, String> myMap = new LinkedHashMap<String, String>();
    pageContext.setAttribute("myMap", myMap);

    List<Person> myList = new ArrayList<Person>();
    pageContext.setAttribute("myList", myList);

    pageContext.setAttribute("person", new Person("Holly", "Hoo"));
%>

myMap is an instance of Map:
<b>
 <c:choose>
   <c:when test="${function:instanceOf(myMap, 'java.util.Map')}">true</c:when>
   <c:otherwise>false</c:otherwise>
  </c:choose>
</b><br/>
myList is an instance of List:
<b>
 <c:choose>
  <c:when test="${function:instanceOf(myList, 'java.util.List')}">true</c:when>
  <c:otherwise>false</c:otherwise>
 </c:choose>
</b><br/><br/>

myMap is an instance of List:
<b>
 <c:choose>
  <c:when test="${function:instanceOf(myMap, 'java.util.List')}">true</c:when>
  <c:otherwise>false</c:otherwise></c:choose>
</b><br/>
myList is an instance of Map:
<b>
 <c:choose>
  <c:when test="${function:instanceOf(myList, 'java.util.Map')}">true</c:when>
  <c:otherwise>false</c:otherwise>
 </c:choose>
</b><br/><br/>

Person has a property called firstName:
<b>
 <c:choose>
  <c:when test="${function:hasProperty(person, 'firstName')}">true</c:when>
  <c:otherwise>false</c:otherwise>
 </c:choose>
</b><br/>
Person has a property called lastName:
<b>
 <c:choose>
  <c:when test="${function:hasProperty(person, 'lastName')}">true</c:when>
  <c:otherwise>false</c:otherwise>
 </c:choose>
</b><br />
Person has a property called id:
<b>
 <c:choose>
  <c:when test="${function:hasProperty(person, 'id')}">true</c:when>
  <c:otherwise>false</c:otherwise>
 </c:choose>
</b><br />

Note: I have used a scriptlet in the above example simple to demonstrate the usage of the functions. The use of scriptlets in JSP is bad practice since it probably means that you are putting your business logic in your JSP. The proper place for such code is in a Controller or a Service.

As you can see from the above example, the usage is pretty simple. If everything went well, the output should look something like this:

myMap is an instance of Map: true
myList is an instance of List: true

myMap is an instance of List: false
myList is an instance of Map: false

Person has a property called firstName: true
Person has a property called lastName: true
Person has a property called id: false

Note: Using the JSP above, the true and false values will actually be on separate lines. I broke the code up in my example for readability. In my actual code, The whole logic expression is in one line.

One important thing to note is that when you use the instanceOf function, you have to provide the fully-qualified class-name. Otherwise, the method will return false.

UPDATE

thetoolman suggested some improvements that uses BeanInfo instead of the reflection API:

public class TagUtils {

    public static boolean instanceOf(Object o, String className) {
        if (o == null || className == null) {
            return false;
        }

        try {
            return Class.forName(className, false, Thread.currentThread().getContextClassLoader()).isInstance(o);
        }

        catch (ClassNotFoundException e) {
            return false;
        }
    }

    public static boolean hasProperty(Object o, String propertyName) {
        if (o == null || propertyName == null) {
            return false;
        }

        BeanInfo beanInfo;
        try {
            beanInfo = java.beans.Introspector.getBeanInfo(o.getClass());
        }

        catch (IntrospectionException e) {
            return false;
        }

        for(final PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) {

            if (propertyName.equals(pd.getName())) {
                return true;
            }
        }
        return false;
    }
}

References

1. JSTL: check if property doesn’t exist (stackoverflow.com)
2. instanceof: Java Glossary (mindprod.com)
3. Class (Java Platform SE 6)

<div style="display: inline-block; margin-right: 5px">
 [ ... wordpress generated code for first image ... ]
</div>
<div style="display: inline-block">
 [ ... wordpress generated code for second image ... ]
</div>

And the rendered content, like this:

Honey and Ham

Ham Jumping

What if you wanted to center the content? That’s pretty simple too:

<div style = "text-align:center">
 <div style="display: inline-block; margin-right: 5px">
   [ ... wordpress generated code for first image ... ]
 </div>

 <div style="display: inline-block">
  [ ... wordpress generated code for second image ... ]
 </div>
</div>

The rendered content looks like this:

Honey and Ham

Ham Jumping

The only problem with this solution is that it won’t work in browsers that fail to implement standards correctly (IE8 does though). But overall, a pretty simple method that should work in most browsers. Also, instead of having to type out the styles every time, you can easily add these to your stylesheet and then use them as you need them.

So, I made the decision to use WordPress. This meant that I would have to migrate all my old posts from my old database into WordPress’s database. Thanks to WordPress’s excellent database-schema documentation, this wasn’t hard at all. I wrote a Perl migration-script to move all my posts, comments, and tags into WordPress. I also had to make some changes to my .htaccess file (and write a redirect php page) to ensure that links in the old format would get translated into the new format. Everything seems to be working pretty well so far! I know there are a few rough edges to sand down (basically the old project pages, which aren’t visible now) but I don’t think it should be that difficult.

To my readers (the two or three of you!) if you spot anything out of the ordinary in my old posts (bad formatting, unparsed tags, broken links) please let me know so that I can fix it! Oh and another thing, since WordPress makes it so easy to add new posts, I think I will be writing a whole lot more!