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