Spring: Expose all Spring beans as HTTP/AJAX service returning content in JSON format in Spring MVC application

Here, a homemade “securized” solution (questionable ??!!!) allowing the generic calls to Spring bean on server side from the client side with Ajax requests on the format:

In fact, this solution exposes the Spring BEANs as a HTTP/AJAX SERVICE, returning a content like JSON objects in a Spring MVC application.

This solution uses several technologies:

• Spring: the HttpRequestHandler interface for the creation of coordinator servlet, the ApplicationContextAware interface for the access of coordinator servlet to the Spring application context;
• Java Reflection (see my last post on Java: Reflection, javap): used in the method’s calls on Spring bean on server side;
• JSON: JSON will be the format of response from server to client;
• SENCHA/ExtJs: used by the Ajax requests and the JSON response’s handling on client side;

I). Server Side components
First, Following the codes of coordinator servlet AjaxToSpringBeanServlet:

Explanations:

• This class AjaxToSpringBeanServlet implements the interface HttpRequestHandler which is a plain handler interface for components that process HTTP requests, analogous to a Servlet. In this example, because we use this solution in a Web application based on Spring MVC, we will use the option recommended by the Spring (2) documentation for the way of exposing an HttpRequestHandler:
  
  (1) The easiest way to expose an HttpRequestHandler bean in Spring style is to define it in Spring’s root web application context and define an HttpRequestHandlerServlet in web.xml, pointing at the target HttpRequestHandler bean through its servlet-name which needs to match the target bean name.

  (2) Supported as a handler type within Spring’s DispatcherServlet, being able to interact with the dispatcher’s advanced mapping and interception facilities. This is the recommended way of exposing an HttpRequestHandler, while keeping the handler implementations free of direct dependencies on a DispatcherServlet environment.
  

• More, this class AjaxToSpringBeanServlet implements also the interface setApplicationContext in order to have a direct access to the Spring Application context which is injected by the following method:
  view source

  print?

  1

  @Override

  2	public void setApplicationContext(ApplicationContext applicationcontext) throws BeansException {

  3	this.context = applicationcontext;

  4

  }

• The method sendJSONReponseToClientJSON converts a model Map to JSON format and send this result to the client. To convert a POJO to JSON, I have use the class org.mortbay.util.ajax.JSON from the library “jetty-util-6.1.9.jar”. It is possible to use another Java libraries like Google Gson that can be used to convert Java Objects into their JSON representation.
  view source

  print?

  1	JSONObject jsonObj = new JSONObject();

  2	jsonObj.putAll(model);

  3	String dataJSON = org.mortbay.util.ajax.JSON.toString(jsonObj);

• The method isValidParameters checks the presence of “beanName” and “beanMethod” parameters; and returns to the client a error message concerning the service’s usage.
• And the last method handleRequest contains the logical business i.e.:
  – retrieve the parameters “beanName” and “beanMethod” from ajax request;

– get the Spring bean due to the “beanName” parameter;

view source

print?

1	Object obj = (Object) context.getBean(beanName);

– use the reflection to invoke the bean’s method requested:

view source

print?

1	Class mClass = obj.getClass();

2	// Only public methods without parameter and returning a object

3	Method m = mClass.getMethod(beanMethod, null);

4	result = m.invoke(obj,null);

– create a Map model object which will be converted to JSON format and sent to client. The keys of this Map are “failure” flag used in error/failure cases; “errorMessage” containing the error message; “success” flag set in normal cases and “data” containing the data object which is the result returned by the call of Spring bean’s method:

view source

print?

1	model.put("failure", "true");

view source

print?

1	model.put("errorMessage", ExceptionUtils.getStackTrace(e));

view source

print?

1	model.put("success", "true");

view source

print?

1	model.put("data", docModel);

So, the web.xml file will be:

and myHUODispatcherServlet-servlet.xml file:

II). Client Side
Here, an example of a SENCHA/ExtJs interface containing a panel:

… and the Ajax request to our service:

Explanations:
In our example, the client sends a request to server to collect all languages via the Spring bean named “languageService” and its method “getAllLanguages” (see the parameters in URL “beanName=languageService&beanMethod=getAllLanguages”).

In Sencha/ExtJs Ajax request, there are several callbacks for:

• success: if the reponse is correctly returned by the server
  view source

  print?

  1	success: function(request, resp) {

• failure: if the reponse is not correctly returned by the server (timeout)
  view source

  print?

  1	failure: function() { // Timeout

In the ‘failure’ case i.e. no reponse received, a timeout message is displayed to client/user.

In the ‘success’ case, the response received, is decoded via EXTJS utility, and a check is done on the ‘success’ field in JSON object corresponding to the Java code:

…if there is not ‘success’ field in response (failure=true), the error message recevied is displayed to client/user.
…otherwise, we range all “data” received which in our case corresponding to a list of ‘Language’ containing at least the ‘isoCode’ property. For each element receveid, we create a ‘checkboxfield’ in the previous panel with the ID ‘languagesChkBxsContainerID’.

… the above codes will produce the below result:

III). Tests and results
Example of results with a list of following POJO, converted to JSON and sent by server to client:

Some examples:

• No parameters: ajaxToSpringBeanService.do
  
• The beanName parameter is missing: ajaxToSpringBeanService.do?beanName=languageService
  
• The beanMethod parameter is missing: ajaxToSpringBeanService.do?beanMethod=getAllLanguages
  
• OK: ajaxToSpringBeanService.do?beanName=languageService&beanMethod=getAllLanguages
  

IV). Conclusion
In this post, we have studied a “securized” homemade solution (questionable ??!!!) exposing the Spring BEANs as a HTTP/AJAX SERVICE, returning a content like JSON objects in a Spring MVC application. However, several comments:

• This solution exposes all Spring BEANs transactionnal or not.
• This solution is “securized” like a normal SPRING MVC controller.
• Currently, this solution allows the calls to public methods without parameters and returning a object of the Spring beans (so “securized”???).
• Yet, it could easily (due to Reflection) expose the private methods, fields, methods with arguments of the Spring beans.
• This solution accepts the calls from all clients which use JSON.
• There are a lot of others Java libraries like DWR that coupled with Spring, enables Java on the server and JavaScript in a browser to interact and call each other.
• More, this homemade solution is easily customized.
• …

Huseyin OZVEREN