injecting spring beans into servlet

SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, config.getServletContext());

checking long running task and timing out using java thread

public boolean checkInBackground() throws InterruptedException {
  final StringBuffer st = new StringBuffer();
  Thread thread = new Thread() {
   public void run() {
    try {
     check();
     st.append("done");
    } catch (Exception e) {
     e.printStackTrace();
    }
   }

   public void check() {
    //long running task
    while(true) {}
   };
  };
  thread.setDaemon(true);
  thread.start();
  thread.join(2 * 1000);
  if (st.toString().equals("done")) {
   return true;
  }
  return false;
 }

check long running task status using callable, future, ExecutorService in java

public boolean checkInBackground() {
  ExecutorService pool = Executors.newFixedThreadPool(1);
  Callable callable = new Callable() {
   @Override
   public Boolean call() throws Exception {
    check();
    return Boolean.TRUE;
   }
  };
  final Future future = pool.submit(callable);
  pool.shutdown();
  Boolean bool = Boolean.FALSE;
  try {
   bool = future.get(1, TimeUnit.SECONDS);
  } catch (Exception e) {
   future.cancel(true);
   bool = Boolean.FALSE;
  }
  return bool;
 }
public boolean check() {
//long running task
return false;
}

eclipselink refresh cache

If JPA 2.0 is used, this can be done using the JPA Cache interface:

em.getEntityManagerFactory().getCache().evictAll();

In JPA 1.0 this can be done using the EclipseLink IdentityMapAccessor:

((JpaEntityManager)em.getDelegate()).getServerSession().getIdentityMapAccessor().invalidateAll();

Source: http://wiki.eclipse.org/EclipseLink/Examples/JPA/Caching

Encrypt Decrypt in java

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class EncryptDecrypt {
 String passPhrase = "";

 public EncryptDecrypt() {
 }

 public EncryptDecrypt(String passPhrase) {
  super();
  this.passPhrase = passPhrase;
 }

 public String decrypt(String encrypted) throws Exception {
  DESKeySpec desKeySpec = new DESKeySpec(passPhrase.getBytes("UTF8"));
  SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
  SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
  BASE64Decoder base64decoder = new BASE64Decoder();
  byte[] encrypedBytes = base64decoder.decodeBuffer(encrypted);
  Cipher cipher = Cipher.getInstance("DES");
  cipher.init(Cipher.DECRYPT_MODE, secretKey);
  byte[] decryptedBytes = (cipher.doFinal(encrypedBytes));
  String decrypted = new String(decryptedBytes);
  return decrypted;
 }

 public String encrypt(String encrypt) throws Exception {
  DESKeySpec desKeySpec = new DESKeySpec(passPhrase.getBytes("UTF8"));
  SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
  SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
  BASE64Encoder base64encoder = new BASE64Encoder();
  byte[] bytes = encrypt.getBytes("UTF8");
  Cipher cipher = Cipher.getInstance("DES");
  cipher.init(Cipher.ENCRYPT_MODE, secretKey);
  String encryped = base64encoder.encode(cipher.doFinal(bytes));
  return encryped;
 }

 public String getPassPhrase() {
  return passPhrase;
 }

 public void setPassPhrase(String passPhrase) {
  this.passPhrase = passPhrase;
 }
}

Spring jms - Sending message using Activemq

import java.io.IOException;

import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.apache.activemq.spring.ActiveMQConnectionFactory;
import org.apache.commons.io.IOUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class JmsMessageSender {
 JmsTemplate jmsTemplate;

 public JmsMessageSender() {
  jmsTemplate = jmsTemplate();
 }

 public ConnectionFactory connectionFactory() {
  ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory();
  activeMQConnectionFactory.setBrokerURL("tcp://localhost:61616");
  return activeMQConnectionFactory;
 }

 public JmsTemplate jmsTemplate() {
  JmsTemplate jmsTemplate = new JmsTemplate();
  jmsTemplate.setConnectionFactory(connectionFactory());
  return jmsTemplate;
 }

 public void sendJmsMessage(String destinationName, final String message) throws IOException {
  jmsTemplate.send(destinationName, new MessageCreator() {
   @Override
   public Message createMessage(Session session) throws JMSException {
    return session.createTextMessage(message);
   }
  });
 }

 public static void main(String[] args) throws Exception {
  final ClassPathResource classPathResource = new ClassPathResource("message1.xml");
  final String message = IOUtils.toString(classPathResource.getInputStream());
  new JmsMessageSender().sendJmsMessage("RequestQueue", message);
 }
}

Junit4 Implementating MethodRule to Start/Stop server

import org.junit.rules.MethodRule;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;

public class ServerMethodRule implements MethodRule {
 Server server = new Server();

 public ServerMethodRule() {
 }

 @Override
 public Statement apply(final Statement base, FrameworkMethod arg1, Object arg2) {
  return new Statement() {
   private void after() {
    try {
     server.stop();
    } catch (Exception e) {
    }
   }

   private void before() {
    try {
     server.start();
    } catch (Exception e) {
    }
   }

   @Override
   public void evaluate() throws Throwable {
    before();
    base.evaluate();
    after();
   }
  };
 }
}

JAXB ValidationEventHandler Demo

import javax.xml.bind.ValidationEvent;
import javax.xml.bind.ValidationEventHandler;
import javax.xml.bind.ValidationEventLocator;

public class ValidationEventHandlerDemo implements ValidationEventHandler {
 public static final boolean IGNORE_ERROR = true;
 public static final boolean THROW_ERROR = false;

 @Override
 public boolean handleEvent(ValidationEvent validationevent) {
  String message = validationevent.getMessage();
  Throwable linkedException = validationevent.getLinkedException();
  int severity = validationevent.getSeverity();
  //
  ValidationEventLocator locator = validationevent.getLocator();
  int lineNumber = locator.getLineNumber();
  int columnNumber = locator.getColumnNumber();
  return IGNORE_ERROR;
 }
}

Java MD5 example with MessageDigest

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import sun.misc.BASE64Encoder;

public class MessageDigestDemo {
 public static void messageDigest() throws NoSuchAlgorithmException {
  MessageDigest instance = MessageDigest.getInstance("SHA");
  byte[] digest = instance.digest("".getBytes());
  BASE64Encoder encoder = new BASE64Encoder();
  String encode = encoder.encode(digest);
  System.out.println(encode);
 }
}

Scheduling jobs using Spring

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;

@Configuration
public class ScheduleConfig {
 int shutdownTimeout = 1 * 60 * 1000;//1 minutes
 private final String cronExpression = "0 0 1 * * ?";//every hour

 public void start() {
  ThreadPoolTaskScheduler threadPoolTaskScheduler = threadPoolTaskScheduler();
  threadPoolTaskScheduler.initialize();
  threadPoolTaskScheduler.schedule((Runnable) task(), new CronTrigger(cronExpression));
 }

        public Runnable task() {
               //return the job to launch
        }

 public void stop() {
  ScheduledExecutorService scheduledExecutorService = threadPoolTaskScheduler().getScheduledExecutor();
  try {
   scheduledExecutorService.shutdownNow();
   if (!scheduledExecutorService.awaitTermination(shutdownTimeout, TimeUnit.SECONDS)) {
    LOG.debug("error during shutdown - did not terminate properly");
   }
  } catch (InterruptedException ie) {
   Thread.currentThread().interrupt();
  }
 }

 public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
  ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
  threadPoolTaskScheduler.setThreadNamePrefix("job");
  return threadPoolTaskScheduler;
 }
}

spring mvc portlet ajax

ViewBookController.java

import java.io.IOException;

import javax.portlet.ActionResponse;
import javax.portlet.ResourceRequest;
import javax.portlet.ResourceResponse;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.portlet.ModelAndView;
import org.springframework.web.portlet.bind.annotation.ActionMapping;
import org.springframework.web.portlet.bind.annotation.RenderMapping;
import org.springframework.web.portlet.bind.annotation.ResourceMapping;

import sample.code.listing.domain.Book;
import sample.code.listing.service.BookService;
import sample.code.listing.utils.LongNumberEditor;
import util.JsonMapper;

@Controller
@RequestMapping("VIEW")
public class ViewBookController {
 static Logger logger = Logger.getLogger(ViewBookController.class);
 @Autowired
 @Qualifier("myBookService")
 private BookService bookService;
 final JsonMapper jsonMapper = new JsonMapper(Book.class);
 final LongNumberEditor longNumberEditor = new LongNumberEditor();

 @ModelAttribute("book")
 public Book getBook(@RequestParam Long isbnNumber) {
  System.out.println("getBook:" + isbnNumber);
  return bookService.getBook(isbnNumber);
 }

 @InitBinder
 public void initBinder(WebDataBinder binder) {
  binder.registerCustomEditor(Long.class, longNumberEditor);
  binder.setDisallowedFields(new String[] { "isbnNumber" });
 }

 @ResourceMapping("jsonOutput")
 public String jsonOutput(ResourceRequest request) throws IOException {
  Long isbnNumber = longNumberEditor.getValue(request.getParameter("isbnNumber"));
  Book book = getBook(isbnNumber);
  request.setAttribute("book", book);
  return "viewBookForm2";
 }

 @RenderMapping(params = "myaction=viewBookForm")
 public String showViewBookForm() {
  return "viewBookForm";
 }

 @ResourceMapping
 public ModelAndView toJson(@ModelAttribute("book") Book book, ResourceRequest request, ResourceResponse response) {
  response.setContentType("text/plain");
  try {
   response.getWriter().println(jsonMapper.toJson(book));
  } catch (IOException e) {
   logger.error("exception serving resource: {}" + e.getMessage());
  }
  return null;
 }

 @ResourceMapping("jsonView1")
 public ModelAndView toJson1(@ModelAttribute("book") Book book, ResourceRequest request, ResourceResponse response) {
  response.setContentType("text/plain");
  try {
   response.getPortletOutputStream().write(jsonMapper.toJson(book).getBytes());
  } catch (IOException e) {
   logger.error("exception serving resource: {}" + e.getMessage());
  }
  return null;
 }

 @ResourceMapping("jsonView2")
 public void toJson2(ResourceRequest request, ResourceResponse response) throws IOException {
  response.setContentType("text/plain");
  try {
   Long isbnNumber = longNumberEditor.getValue(request.getParameter("isbnNumber"));
   response.getPortletOutputStream().write(jsonMapper.toJson(getBook(isbnNumber)).getBytes());
  } catch (IOException e) {
   logger.error("exception serving resource: {}" + e.getMessage());
  }
 }

 @ActionMapping(params = "myaction=viewBook")
 public void viewBook(@ModelAttribute("book") Book book, ActionResponse response) {
  //--this is required. the getBook method is not invoked but the @RequestParam
  //--is still evaluated
  response.setRenderParameter("isbnNumber", book.getIsbnNumber().toString());
  response.setRenderParameter("myaction", "viewBookForm");
 }
}

viewBookForm.jsp

<%@ taglib prefix="portlet" uri="http://java.sun.com/portlet_2_0"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@ page contentType="text/html" isELIgnored="false"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<portlet:actionURL var="viewBookActionUrl">
 <portlet:param name="myaction" value="viewBook" />
</portlet:actionURL>
<portlet:renderURL var="homeUrl">
 <portlet:param name="myaction" value="books" />
</portlet:renderURL>
<portlet:resourceURL var="default1" escapeXml="false" id="default1">
</portlet:resourceURL>
<portlet:resourceURL var="jsonView1" escapeXml="false" id="jsonView">
</portlet:resourceURL>
<portlet:resourceURL var="jsonView2" escapeXml="false" id="jsonView">
</portlet:resourceURL>
<portlet:resourceURL var="jsonOutput" escapeXml="false" id="jsonOutput">
</portlet:resourceURL>

<script type="text/javascript" src="http://code.jquery.com/jquery-1.6.1.js" ></script>
<script type="text/javascript">
 function showJson(url) {
   $.get(url, function(response) {
   $("#ajaxContent").html(response);
  var json = eval(&apos;(&apos; + response + &apos;)&apos;);
  alert(json.name);
   });
 }
 function showJsonMarkup(url) {
   $.get(url, function(response) {
   $("#ajaxMarkup").html(response);
   //alert(${"#ajaxMarkup"}.html())
   });
 }
</script>

<div id="ajaxContent">
</div>

<div id="ajaxMarkup">
</div>

<form:form name="viewBookForm" commandName="book" method="post"
 action="${viewBookActionUrl}">
 <table>
  <tr align="left">
   <a href="${homeUrl}">Home</a>
  </tr>
 </table>
 <table>
  <tr>
   <td>Name:<font style="color: #C11B17;"></font></td>
   <td>${book.name}</td>
   <td><font style="color: #C11B17;"></font></td>
  </tr>
  <tr>
   <td>Author:<font style="color: #C11B17;"></font></td>
   <td>${book.author}</td>
   <td><font style="color: #C11B17;"></font></td>
  </tr>
  <tr>
   <td>ISBN:<font style="color: #C11B17;"></font></td>
   <td>${book.isbnNumber}</td>
   <td><font style="color: #C11B17;"></font></td>
  </tr>
 </table>
</form:form>
<br></br>
<a href="${default1}">json data</a><br/>
<a href="${jsonView1}">json data 1</a><br/>
<a href="${jsonView2}">json data 2</a><br/>
<a href="${jsonOutput}">json markup</a><br/>
<a onclick="showJson(&apos;${jsonView1}&apos;); return false" href="javascript:void(0)">json data ajax 1</a><br/>
<a onclick="showJson(&apos;${jsonView2}&apos;); return false" href="javascript:void(0)">json data ajax 2</a><br/>
<a onclick="showJsonMarkup(&apos;${jsonOutput}&apos;); return false" href="javascript:void(0)">json markup ajax</a><br/>
<br></br>

<form:form name="viewBookForm" commandName="book" method="post"
 action="${homeUrl}">
 <input type="submit" value="Home" name="Home" />
</form:form>

viewBookForm2.jsp

<%@ taglib prefix="portlet" uri="http://java.sun.com/portlet_2_0"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@ page contentType="text/html" isELIgnored="false"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<table>
 <tr>
  <td>Name:<font style="color: #C11B17;"></font></td>
  <td>${book.name}</td>
  <td><font style="color: #C11B17;"></font></td>
 </tr>
 <tr>
  <td>Author:<font style="color: #C11B17;"></font></td>
  <td>${book.author}</td>
  <td><font style="color: #C11B17;"></font></td>
 </tr>
 <tr>
  <td>ISBN:<font style="color: #C11B17;"></font></td>
  <td>${book.isbnNumber}</td>
  <td><font style="color: #C11B17;"></font></td>
 </tr>
</table>

spring mvc portlet deployment to pluto container

Article: http://books.dzone.com/articles/spring-30-portlet-mvc-part-2

Download pluto-2.0.1-bundle and unzip

run startup.bat to start the pluto server

Open the browser and enter http://localhost:8080/pluto/portal in the address bar

Login with pluto/pluto

Download sample code
http://code.google.com/p/portletsinaction/downloads/detail?name=sample_BookCatalog.zip&can=2&q=

unzip the sample_BookCatalog.zip bundle

copy sample_BookCatalog.xml to pluto-2.0.1-bundle\pluto-2.0.1\conf\Catalina\localhost
<Context path="sample_BookCatalog" docBase="../PlutoDomain/sample_BookCatalog.war" crossContext="true"></Context>

Update web.xml with
<servlet>
<servlet-name>bookCatalog</servlet-name>
<servlet-class>org.apache.pluto.container.driver.PortletServlet</servlet-class>
<init-param>
<param-name>portlet-name</param-name>
<param-value>bookCatalog</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>bookCatalog</servlet-name>
<url-pattern>/PlutoInvoker/bookCatalog</url-pattern>
</servlet-mapping>

Move standard.jar and jstl.jar to pluto-2.0.1-bundle\pluto-2.0.1\lib

run ant script to build the sample_BookCatalog.war

deploy the war file to pluto-2.0.1-bundle\pluto-2.0.1\PlutoDomain directory

type http://localhost:8080/pluto/portal/Pluto%20Admin after loggin into pluto admin

In the Portlet Applications, select sample_BookCatalog application and then select bookCatalog portlet, click on "Add Portlet" button

go to http://localhost:8080/pluto/portal/About%20Apache%20Pluto

You should see "Book Catalog" portlet listing out the books

Hurray :)

Simple implementation of DataSource in Java

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.activation.DataSource;
public class ByteArrayDataSource implements DataSource {
private String contentType;
private byte data[];
private int length;
private int offset;
public ByteArrayDataSource(String contentType, byte data[], int offset, int length) {
this.contentType = contentType;
this.data = data;
this.offset = offset;
this.length = length;
}
public ByteArrayDataSource(String contentType, byte data[], int offset, int length,
ByteArrayDataSource byteArrayDataSource) {
this(contentType, data, offset, length);
}
public String getContentType() {
return contentType;
}
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(data, offset, length);
}
public String getName() {
return "ByteArrayDataSource";
}
public OutputStream getOutputStream() throws IOException {
throw new UnsupportedOperationException();
}
}

Spring ws Tips - Unmarshalling attachments

Custom Jaxb2Marshaller to support pdf,tiff,image, etc attachments

import java.util.Iterator;
import javax.activation.DataHandler;
import javax.xml.transform.Source;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.oxm.XmlMappingException;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.oxm.mime.MimeContainer;
import org.springframework.ws.mime.Attachment;
import org.springframework.ws.soap.saaj.SaajSoapMessage;
public class Jaxb2MarshallerWithMimeSupport extends Jaxb2Marshaller {
@Override
public Object unmarshal(Source source, MimeContainer mimeContainer) throws XmlMappingException {
return super.unmarshal(source, new XOPMimeContainer(mimeContainer));
}
public static class XOPMimeContainer implements MimeContainer {
MimeContainer mimeContainer;
public XOPMimeContainer(MimeContainer mimeContainer) {
this.mimeContainer = mimeContainer;
}
public void addAttachment(String s, DataHandler datahandler) {
mimeContainer.addAttachment(s, datahandler);
}
public boolean convertToXopPackage() {
return mimeContainer.convertToXopPackage();
}
public DataHandler getAttachment(String s) {
return mimeContainer.getAttachment(s);
}
public boolean isXopPackage() {
if (mimeContainer != null) {
Object mimeMessage = new DirectFieldAccessor(mimeContainer).getPropertyValue("mimeMessage");
if (mimeMessage instanceof SaajSoapMessage) {
SaajSoapMessage soapMessage = (SaajSoapMessage) mimeMessage;
Iterator attachments = soapMessage.getAttachments();
if (attachments.hasNext()) {
Attachment attachment = attachments.next();
System.out.println(attachment.getContentType());
return true;
}
}
return mimeContainer.isXopPackage();
}
return false;
}
}
}

Spring WS Tips

For PDF/Mime Attachments, use application/xop+xml as the content-type in the DataHandler on the server side

json jackson marshalling unmarshalling using jaxb annotations with indenting output

package util;

import java.io.StringReader;
import java.io.StringWriter;

import org.codehaus.jackson.map.AnnotationIntrospector;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.SerializationConfig.Feature;
import org.codehaus.jackson.xc.JaxbAnnotationIntrospector;

public class JsonMapper {
 Class parameterizedClass;

 public JsonMapper(Class x) {
  this.parameterizedClass = x;
 }

 public T fromJson(String str) {
  if (str == null) {
   return null;
  }
  ObjectMapper mapper = new ObjectMapper();
  AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
  // make deserializer use JAXB annotations (only)
  mapper.getDeserializationConfig().setAnnotationIntrospector(introspector);
  try {
   T readValue = mapper.readValue(new StringReader(str), parameterizedClass);
   return readValue;
  } catch (Exception e) {
   throw new RuntimeException(e);
  }
 }

 public String toJson(T jaxbObject) {
  if (jaxbObject == null) {
   return "null";
  }
  ObjectMapper mapper = new ObjectMapper();
  AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
  // make deserializer use JAXB annotations (only)
  mapper.getDeserializationConfig().setAnnotationIntrospector(introspector);
  // make serializer use JAXB annotations (only)
  SerializationConfig serializationConfig = mapper.getSerializationConfig();
  serializationConfig.setAnnotationIntrospector(introspector);
  serializationConfig.set(Feature.INDENT_OUTPUT, true);
  StringWriter stringWriter = new StringWriter();
  try {
   mapper.writeValue(stringWriter, jaxbObject);
  } catch (Exception e) {
   throw new RuntimeException(e);
  }
  String str = stringWriter.toString();
  return str;
 }
}

web services

Tutorials

web services style

http://www.ibm.com/developerworks/webservices/library/ws-docstyle.html

http://www.ibm.com/developerworks/xml/library/ws-soa-xmlwsdl.html

http://blogs.msdn.com/b/skaufman/archive/2005/05/10/416269.aspx

http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0.pdf

Editor/Tools
soapui for mock

MTOM (Message Transmission Optimization Mechanism).

Java frameworks
jaxws
spring-ws

xsd

Tutorials

http://www.w3schools.com/Schema/default.asp

http://www.xfront.com/GlobalVersusLocal.html

http://www.ibm.com/developerworks/xml/library/ws-soa-xmlwsdl.html

http://blogs.msdn.com/b/skaufman/archive/2005/05/10/416269.aspx

Editor

eclipse plugin

Tools
xmlbeans inst2xsd, xsd2inst

jaxb xjc task

Design patterns
“Venetian Blind” or “Garden of Eden”

Java technology

TODO: jaxb capturing multiple validation errors

Spring ws

Interceptors

Server side

EndpointInterceptor

Client side

ClientInterceptor

Retrieving Soap Attachments in addition to using Object Xml Marshalling on the client side

1. Implement logic in ClientInterceptor handleResponse Method
2. Override WebServiceMessageTemplate and add marshallSendAndRecieve method which accepts WebServiceMessageCallback and WebServiceMessageExtractor