Server based image scaling

When creating a website with many images getting the images to be correctly sized can be a total pain. You can use many tools to resize images but sometimes it is useful to have the server size the image. Passing a full sized image and letting the browser resize it is a total waste of bandwidth (assuming you're reducing the size).

I researched a few ways of doing this and decided to create a servlet to do it for me. The servlet code below implements this for you. Note that it also acts indirectly as a file server that reads from a configured directory. This can allow you to prevent hotlinking or require some other check to serve an image.

package com.xigole.util.images;

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * The ImageResizerServlet is a simple servlet to, well, resize images.
 * It takes advantage of Java 1.5+ constructs to dynamically resize an image in
 * any format supported by Java.  The response is then converted to an jpeg
 * dynamically.
 *
 */
public class ImageResizerServlet extends HttpServlet
{
    /**
     * This member is required for serializable classes.
     */
    private static final long serialVersionUID = 1;
    
    /**
     * The name of the directory to use for images.  This can be overridden
     * in the servlet config.
     */
    private static String imageDir = "catalog_images";

/**
     * The maximum age, in seconds, that a browser should cache any images generated.
     * This defaults to 1 hour and can be overridden in the servlet config.
     */
    private static String maxAge = "3600";

/**
     * The logger used for debugging and error messages.
     */
    private static Log      log = LogFactory.getLog( ImageResizerServlet.class );
    
    
    /**
     * Reads any init-param items from the web.xml for this servlet.
     * 
     * Currently supported parameters:
     * <ul>
     * <li>imageDir - specifies the name of the directory in which to get images.</li>
     * <li>maxAge - value to pass to the browser indicating the max time to cache the image.</li>
     * </ul>
     *   
     */
    public void init( ServletConfig config ) throws ServletException
    {
        super.init( config );
        
        String configImageDir = config.getInitParameter("imageDir");
        
        if( configImageDir != null )
            imageDir = configImageDir;
        
        log.debug( "using \"" + imageDir + "\" as the directory for images" );

String configMaxAge = config.getInitParameter("maxAge");
        
        if( configMaxAge != null )
            maxAge = configMaxAge;
        
        log.debug( "using \"" + maxAge + "\" as the cache timeout value" );
    }

/**
     * doGet does all the work.  It reads the request, reads the image, scales it,
     * and sends it back.
     * 
     * Request parameters:
     *     image - the name of the image.  This is required.
     *     scale - the requested scale.  This is specified in percentage so 100 will
     *             retuls in no scaling.  This is an optional parameter and if it
     *             doesn't exist then the image will be sent back unchanged and at 100%.
     *
     */
    public final void doGet( HttpServletRequest request, HttpServletResponse response )
        throws ServletException, IOException
    {  
        for( java.util.Enumeration e = request.getHeaderNames(); e.hasMoreElements(); )
        {
            String  nextHeaderName = (String)e.nextElement();
            log.debug( "request header name: " + nextHeaderName + " - value: " + request.getHeader( nextHeaderName ) );
        }

String image = request.getParameter( "image" );
        
        if( image == null )
        {
            response.sendError( HttpServletResponse.SC_BAD_REQUEST, "Missing image parameter" );
            return;
        }
        
        String scaleString = request.getParameter( "scale" );
        
        if( scaleString == null )
            scaleString = "100.0";

try
        {
            String fileName = getServletContext().getRealPath( "/" ) +
                              File.separator +
                              imageDir +
                              File.separator +
                              image;

log.debug( "attempting to serve image \"" + fileName + "\" at scale \"" + scaleString + "\"" );

File imageFile = new File( fileName );
            
            if( !imageFile.exists())
            {
                response.sendError(HttpServletResponse.SC_NOT_FOUND,
                                   "File " + image + " not found" );
                return;
            }
            
            BufferedImage sourceImage = ImageIO.read( imageFile );

float scale = Float.parseFloat( scaleString ) / 100;
            int targetWidth = (int)(sourceImage.getWidth() * scale);
            int targetHeight = (int)(sourceImage.getHeight() * scale);

BufferedImage scaledImage = new BufferedImage( targetWidth,
                                                           targetHeight,
                                                           BufferedImage.TYPE_INT_RGB );
            Graphics2D g2d = scaledImage.createGraphics();
            g2d.setRenderingHint( RenderingHints.KEY_INTERPOLATION,
                                  RenderingHints.VALUE_INTERPOLATION_BILINEAR );

g2d.drawImage( sourceImage, 0, 0, targetWidth, targetHeight, null );
            
            //
            // the output is always written as a jpeg
            //
            response.setContentType("image/jpeg");

//
            // allow for caching
            //
            response.setHeader( "Cache-Control", "max-age=" + maxAge );

ImageIO.write( scaledImage, "jpeg", response.getOutputStream() );
        }
        catch(Exception e)
        {
            log.error("Got exception resizing image", e);
            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage() );
        }
    }
}

And in your web.xml you'll need something like: