Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically embedded into Java applications to provide scripting to end users.

Rhino is an implementation of JavaScript in Java. Features include full implementation of JavaScript 1.7 and allows direct scripting of Java and more…

There are some good frameworks available like this one from my friend Fred Polgrady, http://github.com/sustainablecode/datastore

I will provide an easy way of installing Rhino on a mac. Follow these three steps for an easy installation…

1. Download Rhino

2. Create “Java/Extensions” in home directory “~/Library/Java/Extensions”

3. Copy the js.jar file from the downloaded Rhino zip file to “Extensions” directory.

Thats it!! You are all set to use Rhino.

$ java org.mozilla.javascript.tools.shell.Main

Rhino 1.7 release 2 2009 03 22

js> eval(“print(‘hello’)”)

hello

Thats all!!

Ease of Development

Using annoations Servlets join the band wagon of using declarative-style programming along with JPA, EJB3, Spring and the rest. This helpa developing Servlets, Filters more easily with the code and the related configuration in the same place and thus making the web.xml an optional. It’s the Servlet 3.0 supported contianer which will process all the classes at boot time to find out all the annotated servlets, filters and listener classes and made them available for serving. If you don’t want the container to process all the class files to figure out the annotated classes, you can turn it off using the new web.xml configuration parameter metadata-complete on web-app element to true. The other important addition which helps in ease of development and configuration is programmatic setup of serlvets and filters.

The new sample web.xml configuration

1: <web-app xmlns=”http://java.sun.com/xml/ns/javaee” xsi=”http://www.w3.org/2001/XMLSchema-instance” schemalocation=”http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd” version=”3.0″>

2:   <display-name>Sample Web Application to test Servlet 3.0 </display-name>

3:  </web-app>

@WebServlet and @WebFilter are the two main annotations for configuring the servlets and filters in Servlet 3.0.

The urlPatterns attribute of the @WebServlet annotation qualifies the URL’s for this servlets to respond.

1: @WebServlet(name = “helloServlet”, urlPatterns = {“/hello”})

2:  public class HelloServlet extends HttpServlet {

3:  

4:  protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

5:   PrintWriter writer = response.getWriter();

6:   writer.print("<h1>HttpServlet using Servlet 3.0</h1>");

7:  

8:  }

9:  }

Note that the class still needs to extends HttpServlet (It is a mandatory requirement)
Servlet filters and Listeners follow the same pattern except that the class needs to implement Filter and ServletContextListener classes and the annoation @WebFilter, @WebListener respectively

Asynchronous Support

Asynchronous Http Request Processing (aka Comet) is a way that allows you to process a single Http Request using non-blocking I/O. More details about Coment and Asynchronous programming here(http://en.wikipedia.org/wiki/Comet_%28programming%29). Basically all this means is your servlet can continue working on the request while waiting for some other resource to be released or some other operation to be done like a database update.
To enable async support for your servlet, you can enable it using asyncSupported attribute of @WebServlet to true. Enabling this will give you support for few new methods in the Servletrequest itself inclluding startAsync(servletRequest, servletResponse), startAsync(), and getAsyncContext(). Once async attribute is set on the Servlet class you should either call startAsync(servletRequest, servletResponse) or startAsync() method to make an asynchronous request.

A simple example:
1: @WebServlet(“/foo” asyncSupported=true)

 2:  public class MyServlet extends HttpServlet {

 3:   public void doGet(HttpServletRequest req, HttpServletResponse res) {

 4:       AsyncContext aCtx = request.startAsync(req, res);

 5:       ScheduledThreadPoolExecutor executor = new ThreadPoolExecutor(10);

 6:       executor.execute(new AsyncWebService(aCtx));

 7:   }

 8:  }

 9:  

10:  public class AsyncWebService implements Runnable {

11:   AsyncContext ctx;

12:   public AsyncWebService(AsyncContext ctx) {

13:       this.ctx = ctx;

14:   }

15:   public void run() {

16:       // Invoke web service and save result in request attribute

17:       // Dispatch the request to render the result to a JSP.

18:       ctx.dispatch("/render.jsp");

19:  }

20:  }

More detailed tutorial on writing Asynchronous Servlets in my next entry.

Pluggability

A new notion called web fragments has been introduced in servlet 3.0 specification which helps reduce the configuration. A webfragment is a part or all of web.xml configuration that can be specified by any framework or a jar file dropped into the web application. In this way the framework can by default configure itself to work with the application with out the application developer confioguring it.

1: <web-fragment>

 2:  <servlet>

 3:  <description></description>

 4:  <display-name>TestServlet</display-name>

 5:  <servlet-name>TestServlet</servlet-name>

 6:  <servlet-class>sample.TestServlet</servlet-class>

 7:  </servlet>

 8:  <servlet-mapping>

 9:  <servlet-name>TestServlet</servlet-name>

10:  <url-pattern>/TestServlet</url-pattern>

11:  </servlet-mapping>

12:  </web-fragment>

Let us see an example,
The BlogSearchService has two public methods, first method filterBlogsByAuthor takes an author name and a list of blogs and returns all the blogs written by that particular order author.
The other business method searchBlogs will take a search paramter and the author, it will get all the blogs by the search parameter using a custom logic and do some other house keeping tasks like sorting them by published date and number of comments and then filter the methods by author.

package com.teja.blogs;

import java.util.Collections;import java.util.List;

/**** @author Teja*/public class BlogSearchService {

      public List<Blog> searchBlogs(String searchString, String author){

              //do some custom logic here on these blogs like sorting them by posted date.              return filterBlogsByAuthor(author, Collections.EMPTY_LIST);      }

      public List<Blog> filterBlogsByAuthor(String author, List<Blog> blogs){
             return Collections.EMPTY_LIST;
 }

}

When writing the test cases for the second method, I don’t want to test the other public method filterByAuthor as
(i)it has already been tested by other test cases,
(ii)I want to keep my test cases more unit.

So in my test case where I am testing my searchBlogs, I am creating the mock service class which has mock methods only for filterBlogsByAuthor, but the actual mehtod(searchBlogs) which is about to be tested is not.
As usual you can do expectations on the mock class, replay and verify as if it is some other external resource being mocked.

To create a partial mock class of the service, the extra parameter you need to pass is the name of the method to be mocked and the parameter types it accepts (coz, it need to know which version of the method you want to mock if you have overloaded methods)

Here is our test class:

package com.teja.blogs;

import java.util.Collections;import java.util.List;import org.junit.Test;import org.easymock.classextension.EasyMock;

/**** @author Teja*/public class BlogSearchServiceTest {

        @Test        
public void testSearchBlogs() throws NoSuchMethodException {
 String author = "Teja";
BlogSearchService blogSearchService =
EasyMock.createMock(BlogSearchService.class,BlogSearchService.class.getMethod("filterBlogsByAuthor", 
new Class[]{String.class, List.class}));
EasyMock.expect(blogSearchService.filterBlogsByAuthor(author, Collections.EMPTY_LIST)).andReturn(Collections.EMPTY_LIST);                EasyMock.replay(blogSearchService);                blogSearchService.searchBlogs("easymock", author);                EasyMock.verify(blogSearchService);        }

}

Lets get started first by installing the gem.

sudo gem install will_paginate

To check whether the plugin installed successfully or not, you can do the following in your rails console.

123	defined? WillPaginate[].paginateActiveRecord::Base.respond_to? :paginate

Now lets add pagination support to an imaginary page listing all the clients

123	def list_clients @clients = Client.paginate(:page => params[:page], :per_page => 5) end

and then render the pagination in the ui using this simple snippet

123456789101112131415

<h3>Clients</h3><%= will_paginate @clients %><!--Loop through all the clients and printem--><table width=100% cellpadding=0 cellspacing=0 border=0> <% for @client in @clients do%> <tr class='client_details'> <td align='center'><%=@client.client_name.upcase%></td> <td> <%=@client.address_line_1%>,<%=@client.address_line_2%><br /> <%=@client.city%>,<%=@client.state%>,<%=@client.zip%> </td> </tr> <%end%></table>

The code will add the links to previous/next page along with the page numbers to naviage.
The next few lines of code is just to print the client details.

You can download spring, spring web services here.

We are about to develop a web service which search the blogs based on a search criteria on title string and published date.

So lets get started,

1.Create a web application
This is a general spring web MVC application. for a skeleton application, you can just run this maven archetype to quickly start with,

mvn archetype:create -DarchetypeGroupId=org.springframework.ws \
-DarchetypeArtifactId=spring-ws-archetype \
-DarchetypeVersion=1.5.4 \
-DgroupId=com.teja \
-DartifactId=spring-ws-test

Or you can just add the spring nature to your existing web application by configuring the web.xml shown in the next step. Here is the file structure I am using for this simple demo.

2.Configure web.xml.

Spring strongly supports only contract first web services for several reasons like Fragility, performance, re usability and versioning.
You can find more information visit this link

So lets start first by developing our XSD….

This is a plain regular xsd where we will define all our xml elements going to create our wsdl file.
Lets define our blog object, the blog is just a complex type object with three properties the “Title” for the blog, the “AbstractDetail” of the blog and the date when the blog is published “PublishedDate”. This can be defined in the xml complex type
as follows…

Next step is defining the search criteria object, I am wrapping the search criteria into a seperate object so that in future, we can extend the search criteria by adding more elements like author, subject. Here the xsd definition of the search criteria
object with two fields title and published date.

The next stepa are creating the actual request object for our web service, which is basically a wrapper on the search criteria and our response object which is just a array/list of blog objects (which can be either zero size, if search results nothing
or can be of size n if search returns n objects).
Here is our completed xsd,

The next in developing our web services is defining our contract, the WSDL file.
Here is the complete version the WSDL file.
Essentilly we are improting the xsd file which we had created in the earlier step to use them in the wsdl
Then create the message parts, the port and the binding operation for the blog search service. This is self explanatory.

next step is creating the JAXB objects for your xsd elements using xjc compiler. you can either craft the JAXB objects by hand or just
use the xjc compiler. I prefer the later one. see https://jaxb.dev.java.net/guide/ for more details. (My Intellij Idea supports generating JAXB objects directly from xsd).

(Posting all the code is not practical, So I am moving here ahead posting the important parts)
Here is the endpoint

now the last and more important step, putting all the things together to deploy the service,configuring the spring-ws-servlet.xml

First and the most important point here is I am autowiring the endpoint by using the annotation @Endpoint.

So in the context.xml, we are defining the wsdl to be exposed as a bean using the class org.springframework.ws.wsdl.wsdl11.SimpleWsdl11Definition.
I am specifying the JAXBMarshaller and injecting all the jaxb classes.
I am also configuring a couple of beans for validating and logging each and every request and response.

you can access the wsdl at http://localhost:8080/spring-ws-test/wsdl/BlogSearch.wsdl

Java unit testing frameworks like jUnit, TestNG with some other pretty frameworks like easy mock and easy mock class extensions help us test individual classes with mocking out the external dependent classes/resources and make the tests more “unit”.

Spring out of the box supports unit testing with jUnit and TestNG. Spring provides seperate set of classes help you unit test your spring classes.

Spring 2.5 in its org.springframework.test.context package has a set of classes to have better unit testing using jUnit4.

I am about to show an example of testing a service called BlogSearchService. The service simply calls a method in the blogDAO which searches the blogs based on the keyword and return a list of blogs. So here my service class is simple, it calls the DAO. So in my test I just have to make sure that it makes a DAO call and the result is then returned to the client.

Lets see the code for BlogSearchService and BlogSearchServiceImpl,

BlogSearchService.java

BlogSearchServiceImpl.java

Here is the test case for BlogSearchService,
In the test case, the ContextConfiguration helps in specifying the config file to load. In the @Before (setup method for the test case) I am creating the instance of BlogSearchServiceImpl (but instead you can autowire it). Then I am creating the mock object of blogDAO and setting it to the BlogSearchService. In the actual test method, I expect that the searchBlogByKeyWord on the blogDAO and I am expecting it retuning no posts. You can do any asserts here depending on the actual business.

SpringJUnit4ClassRunner is a custom extension of JUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit 4.4+ tests by means of the TestContextManager and associated support classes and annotations.

It’s so simple and sweet testing spring classes with jUnit and easymock. Isn’t it?

Spring security offers a simple configuration based security for your web applications helping you secure your web application with out littering your business logic with any security code. It provides securing URL’s based on the Role (Authorities), securing your business methods based on the ACL’s.

The first step in hooking up the spring security to your web application is by specifying the DelegatingFilterProxy in your web.xml.

If you want to externalize all of your security related configuration into a separate file, you can do so and add that to your context location param.

Now comes the part of security configuration for your application, Adding the URL security patterns is pretty simple and straight forward. Add all the URL patterns which you want to secure and add the wild card pattern at the end. You need to have some default principal and role even for non logged in users as you need to give access to pages like log in, register and forgot password kind of functionality even to non logged in users.

I tried to add comments to pretty much every element which I am using here.
As an example I added just a wild card intercept url which make every page of my application secure. You need to exclude different urls based on the roles.

Following is my custom implementation of AuthenticationEntryPoint, which currently is not doing any thing except leveraging the commence to its super class which is the spring implementation of AuthenticationProcessingFilterEntryPoint. I hooked it to add any custom logic.

This is my custom authentication manager which actually does the custom login of the user. It will throw an BadCredentialsException in case of invalid credentials or thorws a AuthenticationServiceException in case of a service error (Database error, SQL error or any other error).

At the client side (jsp), the simple configuration you need to do is post the request to”/j_spring_security_check” with parameters “j_username” and “j_password”.

That’s pretty much all you need to do for enabling spring security to your existing web application. I will try to explain about doing the method security using ACL’s and configuring the view using spring security tags in another post.