Flaming Penguin

How to find out where a java class was loaded from?

flamingpenguin — Tue, 24 Apr 2012 16:34:04 +0000

If you need to find out which jar file a Java class was loaded from you can find out by examining the code source location in the protection domain:

MyClass.class.getProtectionDomain().getCodeSource().getLocation()

Implement toString method on DOMSource when marshalling with JAXB

flamingpenguin — Tue, 03 Apr 2012 14:56:06 +0000

When serialising with JAXB to a DOMSource the object that results does not have a useful implementation of toString and alot of boiler plate is required to set up the marshalling. Here is some code that returns a DOMSource from an arbitrary JAXB annotated object with the toString method of the object return the XML representation:

public class SerialisationHelper
{
   private final String marshalledBean;
   private final Document document;
 
   private SerialisationHelper(final Object bean) throws JAXBException, ParserConfigurationException
   {
      document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
 
      final Marshaller marshaller = JAXBContext.newInstance(bean.getClass()).createMarshaller();
      marshaller.marshal(bean, document);
      final StringWriter writer = new StringWriter();
      marshaller.marshal(bean, writer);
      marshalledBean = writer.toString();
   }
 
   @Override
   public String toString()
   {
      return marshalledBean;
   }
 
   private Document toDocument()
   {
      return document;
   }
 
   public static DOMSource marshalled(final Object entity)
   {
      try
      {
         final SerialisationHelper serialisationHelper = new SerialisationHelper(entity);
         return new DOMSource(serialisationHelper.toDocument()) {
            @Override
            public String toString()
            {
               return serialisationHelper.toString();
            }};
      }
      catch (final JAXBException e)
      {
         throw new RuntimeException("unable to marshal " + entity, e);
      }
      catch (final ParserConfigurationException e)
      {
         throw new RuntimeException("unable to marshal " + entity, e);
      }
   }
}

Refactoring Ideas: Replace maven transitive dependency with direct dependency

flamingpenguin — Fri, 30 Mar 2012 11:25:38 +0000

It would be useful to have a tool that can traverse the maven transitive dependency tree, find anything that the project depends on directly and include it as a direct dependency.

Refactoring Ideas: Replace static method with same named static method

flamingpenguin — Wed, 28 Mar 2012 15:18:27 +0000

Want to produce the same kind of import in the affected classes (static, normal or fully qualified):

public static String repeat(final int count, final char character)
{
   return org.apache.commons.lang3.StringUtils.repeat(character, count);
}

Refactoring Ideas: inline method with flag parameter

flamingpenguin — Wed, 28 Mar 2012 15:10:42 +0000

Check all calls to see if the value of the flag can be analysed, if so inline everywhere (otherwise tell the developer where it is ambiguous):

   public static String pad(final String string, final int length, final char character, final boolean before)
   {
      if(before)
      {
         return leftPad(string, length, character);
      }
      else
      {
         return rightPad(string, length, character);
      }
   }

Refactoring Ideas: Remove unused

flamingpenguin — Wed, 28 Mar 2012 11:13:58 +0000

Starting at some given point, like an API entry point, remove that entry point as well as all code that is now unused! This would be very useful when removing parts of an API to ensure that all code which … Continue reading →

Refactoring Ideas: Replace static method

flamingpenguin — Wed, 28 Mar 2012 11:03:19 +0000

Replace all calls to one static method with calls to another static method (can be done by replacing the implementation then doing an “inline”, but it could be one command). For example, this would be useful when replacing one utility … Continue reading →

Refactoring Ideas: Move static methods with only one use to the using class

flamingpenguin — Wed, 28 Mar 2012 11:00:59 +0000

If a static method has only one use, then it can be moved the class where it is being used and made private.

Webhooks – event driven REST

flamingpenguin — Fri, 16 Mar 2012 11:48:08 +0000

From the site:

The concept of a Webhook is simple. A WebHook is an HTTP callback: an HTTP POST that occurs when something happens; a simple event-notification via HTTP POST.

A web application implementing WebHooks will POST a message to a URL when certain things happen. When a web application enables users to register their own URLs, the users can then extend, customize, and integrate that application with their own custom extensions or even with other applications around the web. For the user, WebHooks are a way to receive valuable information when it happens, rather than continually polling for that data and receiving nothing valuable most of the time.

Funcito – Java function wrapper library

flamingpenguin — Mon, 12 Mar 2012 17:55:43 +0000

Funcito is a Java library that simplifies access to your favorite functional programming APIs by wrapping Java methods as the function-type objects defined in those libraries.