Using Spring HTTP Invoker

Spring provide features to integrate classes for remoting support using various technologies like Remote Method Invocation (RMI), Hessian, Burlap, JAX-WS,Java Messaging Service (JMS), Advanced Messaging Queuing Protocol (AMQP) and Spring HTTP Invoker.It is recommended that you must have bit of idea about proxy pattern as Spring remoting framework follow the Proxy software pattern. Here we will be looking into Spring HTTP Invoker only. 

Spring HTTP Invoker comes into picture when Spring recognizes the need of HTTP based client server communication and which uses java serialization because RMI  services uses java serialization but it difficult to work with across firewall and on the other side HTTP based services such as Hessian and Burlap work well across firewall but they use there proprietor serialization method not java serialization.  


Spring HTTP Invoker is a special remoting strategy which allows for Java serialization via HTTP, supporting any Java interface clients to communicate with Spring server using HTTP service without client knowledge of implementation. As it is working on HTTP service it will be easy to use it across network with firewall.
 

Fig.1. Spring HTTP Invoker Flow

Spring HTTP Invoker flow steps:-

• Client invoke the proxy's service method which is being handle by HttpInvokerProxyFactoryBean.
• The proxy convert the method call to HTTP remote call.
• The HTTP Service Adapter intercept to remote call and create HttpInvokerServiceExporter.
• It the forward the method call to Service. 

Fig. 2. Dispatcher Flow

Spring HTTP invoker remote service is simple and easy. Lets get into the implementation of Spring HTTP Invoker client server model using web container and without web container.

First we start where Spring HTTP Invoker server running in web container.

Step 1. Create interface for the client

Application.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public interface Application {
4. String getGreeting(final String name);
5. }

Step 2. Create the service for client

ApplicationService.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public class ApplicationService implements Application {
5. @Override
6. public String getGreeting(String name) {
7. return "Hi " + name + " !!";
8. }
10. }

Step 3. Create the web.xml

web.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns="http://java.sun.com/xml/ns/javaee"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
5. id="WebApp_ID" version="3.0">
7. <display-name>Application</display-name>
9. <welcome-file-list>
10. <welcome-file>pages/index.jsp</welcome-file>
11. </welcome-file-list>
13. <servlet>
14. <servlet-name>Application</servlet-name>
15. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
16. <init-param>
17. <param-name>contextConfigLocation</param-name>
18. <param-value>/WEB-INF/WebAppContext/SpringServletContext.xml
19. </init-param>
20. <load-on-startup>1</load-on-startup>
21. </servlet>
23. <servlet-mapping>
24. <servlet-name>Application</servlet-name>
25. <url-pattern>*.http</url-pattern>
26. </servlet-mapping>
28. </web-app>

Step 4. Create the Spring Servlet Application context. 

This is where we exposing the beans as HTTP service. In case of web application request handler by DispatcherServlet then dispatches to HTTP invoker service. This service translate them into method call in Spring manages beans.  
Here applicationService is the service bean and /greeting.http is Spring HTTP service exporter bean.
      

WEB-INF\WebAppContext\SpringServletContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans:beans xmlns="http://www.springframework.org/schema/mvc"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:beans="http://www.springframework.org/schema/beans"
5. xmlns:context="http://www.springframework.org/schema/context"
6. xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
7. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
8. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
10. <annotation-driven />
11. <context:component-scan base-package="andy.blog.spring.remoting.httpinvoker.controller" />
12. <beans:bean
13. class="org.springframework.web.servlet.view.InternalResourceViewResolver">
14. <beans:property name="prefix" value="/pages/" />
15. <beans:property name="suffix" value=".jsp" />
16. </beans:bean>
18. <!-- Application Service -->
19. <beans:bean id="applicationService" class="andy.blog.spring.remoting.httpinvoker.service.ApplicationService" />
21. <!-- Exporter -->
22. <beans:bean name="/greeting.http"
23. class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
24. <!-- Application Service reference -->
25. <beans:property name="service" ref="applicationService" />
26. <!-- Application interface -->
27. <beans:property name="serviceInterface" value="andy.blog.spring.remoting.httpinvoker.service.Application" />
28. </beans:bean>
30. </beans:beans>

Step 5. Application Context of Spring HTTP Invoker client. Here HttpInvokerProxyFactoryBean is a proxy factory for creating HTTP Invoker service proxies. serviceUrl is the service url where client send the HTTP request and it is create HTTP invoker service exporter object and invokes the actual service method call.

applicationContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans.xsd">
7. <bean id="applicationClient"
8. class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
9. <property name="serviceUrl"
10. value="http://localhost:9090/SpringHttpService/greeting.http" />
11. <property name="serviceInterface" value="andy.blog.spring.remoting.httpinvoker.service.Application" />
12. </bean>
14. </beans>

Step 6. To access service via HTTP create the Client.

ApplicationClient.java

1. package andy.blog.spring.remoting.httpinvoker.client;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
5. import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;
7. import andy.blog.spring.remoting.httpinvoker.service.Application;
9. public class ApplicationClient {
11. public static void main(String...pram) {
12. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
13. HttpInvokerProxyFactoryBean httpInvokerProxyFactoryBean = context.getBean(HttpInvokerProxyFactoryBean.class);
14. Application application = (Application) httpInvokerProxyFactoryBean.getObject();
15. System.out.println("Start Application Client ");
16. System.out.println(application.getGreeting("Tom"));
17. System.out.println(application.getGreeting("Harry"));
18. System.out.println(application.getGreeting("James"));
19. System.out.println(application.getGreeting("Andy"));
20. System.out.println("End Application Client ");
21. }
23. }

Run the Spring HTTP Invoker server side into some web container and the run the client.

Start Application Client
Hi Tom !!
Hi Harry !!
Hi James !!
Hi Andy !!
End Application Client
 

Now we will see how to create Spring HTTP Invoker server running in non-web container and how to write a test case for that.
Repeat Step 1 create an interface for the client.

We will re-write the HTTP service method to distinguishes from above service method. Just changed the return message text.

ApplicationService.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public class ApplicationService implements Application {
5. @Override
6. public String getGreeting(String name) {
7. return "Hi " + name + " !! This is non web service"; // message is changed
8. }
10. }

Simple HTTP server applicationContext.xml here application service & HTTP service exporter are same as above discussed but we here used org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter instead of HttpInvokerServiceExporter. Here
org.springframework.remoting.support.SimpleHttpServerFactoryBean is used to create simple HTTP Server based on the HTTP server that is included in Sun's JRE.

applicationContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
6. xmlns:context="http://www.springframework.org/schema/context"
7. xmlns:util="http://www.springframework.org/schema/util">
9. <context:annotation-config />
11. <!-- Application Service -->
12. <bean name="applicationService"
13. class="andy.blog.spring.remoting.httpinvoker.service.ApplicationService" />
15. <!-- Exporter -->
16. <bean name="serviceExporter"
17. class="org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter">
18. <property name="serviceInterface"
19. value="andy.blog.spring.remoting.httpinvoker.service.Application" />
20. <property name="service" ref="applicationService" />
21. </bean>
23. <!-- Http Web Server -->
24. <bean id="httpServer"
25. class="org.springframework.remoting.support.SimpleHttpServerFactoryBean">
26. <property name="contexts">
27. <util:map>
28. <entry key="/SpringHttpService/greeting.http" value-ref="serviceExporter" />
29. </util:map>
30. </property>
31. <property name="port" value="9090" />
32. </bean>
34. <!-- For JUnit Test -->
35. <bean id="remotedApplicationService"
36. class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
37. <qualifier value="remoted" />
38. <property name="serviceUrl"
39. value="http://localhost:9090/SpringHttpService/greeting.http" />
40. <property name="serviceInterface"
41. value="andy.blog.spring.remoting.httpinvoker.service.Application" />
42. </bean>
43. </beans>

We have to create a simple HTTP server using Sun's package. This is required to to run the HTTP server for our client application.

ApplicationServer.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
6. import com.sun.net.httpserver.HttpServer;
7. public class ApplicationServer {
9. public static void main(String[] args) {
10. ApplicationContext context = new ClassPathXmlApplicationContext("/applicatonContext.xml");
11. HttpServer appServer = (HttpServer) context.getBean("httpServer");
12. }
14. }

Test case to make sure our HTTP invoker service work's fine.

ApplicationServiceTest.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. import static org.junit.Assert.assertEquals;
4. import static org.junit.Assert.assertTrue;
6. import org.junit.Test;
7. import org.junit.runner.RunWith;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.beans.factory.annotation.Qualifier;
10. import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;
11. import org.springframework.test.context.ContextConfiguration;
12. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
13. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
15. @RunWith(SpringJUnit4ClassRunner.class)
16. @ContextConfiguration(inheritLocations = true, locations = { "/applicatonContext.xml" })
17. public class ApplicationServiceTest extends AbstractJUnit4SpringContextTests {
19. @Autowired(required = true)
20. @Qualifier("remoted")
21. private Application application;
23. @Test
24. public void getGreetingTestUsingConfiguredClient() throws Exception {
25. String greeting = application.getGreeting("Tom");
26. assertEquals("Hi Tom !! This is non web service", greeting);
27. System.out.println(greeting);
28. assertTrue("Should not be the implementation", !application.getClass().equals(ApplicationService.class));
29. }
31. @Test
32. public void getGreetingTestManually() throws Exception {
33. HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();
34. proxy.setServiceInterface(Application.class);
35. proxy.setServiceUrl("http://localhost:9090/SpringHttpService/greeting.http");
36. proxy.afterPropertiesSet();
37. Application application = (Application) proxy.getObject();
38. String greeting = application.getGreeting("tester");
39. assertEquals("Hi tester !! This is non web service", greeting);
40. System.out.println(greeting);
41. assertTrue("Should not be the implementation", !application.getClass().equals(ApplicationService.class));
42. }
43. }

If you run the above test or above client you get below output.
Hi tester !! This is non web service
Hi Tom !! This is non web service

Well Spring HTTP Invoker is quite easy to implement you just need a reason to run two application on different JVMs.