package utils; 

import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.GraphicsConfiguration; 
import java.awt.GraphicsDevice; 
import java.awt.GraphicsEnvironment; 
import java.awt.HeadlessException; 
import java.awt.Image; 
import java.awt.Transparency; 
import java.awt.image.BufferedImage; 
import java.awt.image.ColorModel; 
import java.awt.image.PixelGrabber; 
import java.io.File; 
import java.io.FileNotFoundException; 
import java.io.IOException; 

import javax.swing.Icon; 
import javax.swing.ImageIcon; 

import sun.awt.shell.ShellFolder; 

public class CommonTool {   
    public static BufferedImage getImageByFileTyle(String filename)   
            throws FileNotFoundException {   
        File file = null;   
        String extension = filename.substring(filename.lastIndexOf("."))   
                .toLowerCase();   
        try {   
            file = File.createTempFile("icon", extension);   
        } catch (IOException e) {   
            // TODO Auto-generated catch block   
            e.printStackTrace();   
        }   
        return toBufferedImage(toImage(toIcon(file)));   
   
    }   
   
    public static Icon toIcon(File file) throws FileNotFoundException {   
        ShellFolder shellFolder = ShellFolder.getShellFolder(file);   
        Icon icon = new ImageIcon(shellFolder.getIcon(true));   
        return icon;   
    }   
   
    public static Image toImage(Icon icon) {   
        if (icon instanceof ImageIcon) {   
            return ((ImageIcon) icon).getImage();   
        } else {   
            int w = icon.getIconWidth();   
            int h = icon.getIconHeight();   
            GraphicsEnvironment ge = GraphicsEnvironment   
                    .getLocalGraphicsEnvironment();   
            GraphicsDevice gd = ge.getDefaultScreenDevice();   
            GraphicsConfiguration gc = gd.getDefaultConfiguration();   
            BufferedImage image = gc.createCompatibleImage(w, h);   
            Graphics2D g = image.createGraphics();   
            icon.paintIcon(null, g, 0, 0);   
            g.dispose();   
            return image;   
        }   
    }   
   
    private static boolean hasAlpha(Image image) {   
        // If buffered image, the color model is readily available   
        if (image instanceof BufferedImage) {   
            BufferedImage bimage = (BufferedImage) image;   
            return bimage.getColorModel().hasAlpha();   
        }   
   
        // Use a pixel grabber to retrieve the image's color model;   
        // grabbing a single pixel is usually sufficient   
        PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);   
        try {   
            pg.grabPixels();   
        } catch (InterruptedException e) {   
        }   
   
        // Get the image's color model   
        ColorModel cm = pg.getColorModel();   
        return cm.hasAlpha();   
    }   
   
    // This method returns a buffered image with the contents of an image   
    public static BufferedImage toBufferedImage(Image image) {   
        if (image instanceof BufferedImage) {   
            return (BufferedImage) image;   
        }   
   
        // This code ensures that all the pixels in the image are loaded   
        image = new ImageIcon(image).getImage();   
   
        // Determine if the image has transparent pixels; for this method's   
        // implementation, see Determining If an Image Has Transparent Pixels   
        boolean hasAlpha = hasAlpha(image);   
   
        // Create a buffered image with a format that's compatible with the   
        // screen   
        BufferedImage bimage = null;   
        GraphicsEnvironment ge = GraphicsEnvironment   
                .getLocalGraphicsEnvironment();   
        try {   
            // Determine the type of transparency of the new buffered image   
            int transparency = Transparency.OPAQUE;   
            if (hasAlpha) {   
                transparency = Transparency.BITMASK;   
            }   
   
            // Create the buffered image   
            GraphicsDevice gs = ge.getDefaultScreenDevice();   
            GraphicsConfiguration gc = gs.getDefaultConfiguration();   
            bimage = gc.createCompatibleImage(image.getWidth(null), image   
                    .getHeight(null), transparency);   
        } catch (HeadlessException e) {  
            // The system does not have a screen   
        }   
   
        if (bimage == null) {   
            // Create a buffered image using the default color model   
            int type = BufferedImage.TYPE_INT_RGB;   
            if (hasAlpha) {   
                type = BufferedImage.TYPE_INT_ARGB;   
            }   
            bimage = new BufferedImage(image.getWidth(null), image   
                    .getHeight(null), type);   
        }   
   
        // Copy image to buffered image   
        Graphics g = bimage.createGraphics();   
   
        // Paint the image onto the buffered image   
        g.drawImage(image, 0, 0, null);   
        g.dispose();   
   
        return bimage;   
    }   
}   

<img src="uploaddispalyIcon?dirName=<%=pathdir+"upload/"%>${name}" style="width:15px;height:15px;"/> 

public void dispalyIcon() {   
        HttpServletResponse response = ServletActionContext.getResponse();   
        response.setContentType("image/png");  
        BufferedImage myImage=null; 
        OutputStream sos =null; 
        try {   
             sos = response.getOutputStream();   
            myImage = CommonTool.getImageByFileTyle(dirName);   
            ImageIO.write(myImage, "png", sos);   
              
        } catch (IOException e) {   
            // TODO Auto-generated catch block   
            e.printStackTrace();   
        }finally{ 
         if(null!=myImage&&null!=sos){ 
           
                try { 
                 myImage.flush(); 
     sos.flush(); 
      sos.close();  
    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    }   
                
         } 
        } 
           
    }