ImageUtils_fimageutils::imageresize-CSDN博客

java中经常需要上传图片，对图片类型进行校验，常常使用的校验是通过文件后缀或者getContentType来判断文件类型是否符合，但是如果你使用了flash上传，有可能得到的图片类型为：application/octet-stream（任意的二进制数），如果你将这个类型加入到了判断条件里边实际上就没有多大意义了，所以确切的文件类型校验就需要如下判断了。所以可以考虑如下操作。

java图片处理类包含如下类：

第一：图片类型类：

    Java代码   
    
  
 /** 
  * 图片类型 
  *  
  * @author  
  * @since 2010-5-19 
  */  
 public enum ImageType {  
   
     unknown(0, "unknown"), jpg(1, "jpg"), gif(2, "gif"), png(3, "png"), bmp(4,  
             "bmp");  
   
     private int code;  
     private String name;  
   
     ImageType(int code, String name) {  
         this.code = code;  
         this.name = name;  
     }  
   
     public int getCode() {  
         return code;  
     }  
   
     public String getName() {  
         return name;  
     }  
   
     /** 
      * 将后缀转换成图片类型, JPEG将转成jpg 
      *  
      * @param suffix 
      * @return 
      */  
     public static ImageType toImageType(String suffix) {  
         if (suffix == null || "".equals(suffix)) {  
             return unknown;  
         }  
         suffix = suffix.toLowerCase();  
         if ("jpeg".equals(suffix)) {  
             suffix = "jpg";  
         }  
         try {  
             return valueOf(suffix);  
         } catch (Exception e) {  
             return unknown;  
         }  
     }  
   
     /** 
      * 判断图片类型 
      *  
      * @param suffix 
      * @return 
      */  
     public static boolean isAcceptType(String suffix) {  
         if (suffix == null || "".equals(suffix)) {  
             return false;  
         }  
         if ("jpeg".equalsIgnoreCase(suffix)) {  
             return true;  
         }  
         ImageType type = ImageType.valueOf(suffix.toLowerCase());  
         if (type != null && type.getCode() > 0 && type.getCode() < 5) {  
             return true;  
         }  
         return false;  
     }  
   
     public static boolean isAcceptType(ImageType type) {  
         if (type == null) {  
             return false;  
         }  
         return isAcceptType(type.getName());  
     }  
 }  

图片扩展信息类：

    Java代码   
    
  
 import java.io.Serializable;  
   
 /** 
  * JPG的EXIT信息 ,相关规范参考： 1.* EXIF.org http://www.exif.org/ 2.* Opanda 
  * http://www.opanda.com/cn/iexif/exif.htm 3.* EXIF 2.1 
  * 官方标准（PDF文档）http://www.exif.org/Exif2-1.PDF 4.* EXIF 2.2 
  * 官方标准（PDF文档）http://www.exif.org/Exif2-2.PDF 5.* EXIF 文件格式说明 
  * http://park2.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html 
  *  
  * @author  
  * @since 2010-5-19 
  */  
 public class ImageExif implements Serializable {  
   
     private static final long serialVersionUID = 4713490466591635082L;  
   
     private String ImageDescription;// 图像描述、来源. 指生成图像的工具 　　  
     private String Artist;// 作者 有些相机可以输入使用者的名字 　　  
     private String Make;// 生产者 指产品生产厂家 　　  
     private String Model;// 型号 指设备型号 　　  
     private String Orientation;// 方向 有的相机支持，有的不支持 　　  
     private String XResolution; // X方向分辨率  
     private String YResolution;// Y方向分辨率  
     private String ResolutionUnit;// 分辨率单位 一般为PPI  
     private String Software;// 软件 显示固件  
     private String Firmware;// 版本  
     private String DateTime;// 日期和时间  
     private String YCbCrPositioning;// 色相定位 　　  
     private String ExifOffsetExif;// 信息位置，定义Exif在信息在文件中的写入，有些软件不显示。  
     private String ExposureTime;// 曝光时间 即快门速度 　  
     private String FNumber; // 光圈系数  
     private String ExposureProgram;// 曝光程序 指程序式自动曝光的设置，各相机不同,可能是Sutter  
     // Priority（快门优先）、Aperture Priority（快门优先）等等。  
     private String IsoSpeedRatings;// 感光度  
     private String ExifVersion;// Exif版本  
     private String DateTimeOriginal;// 创建时间  
     private String DateTimeDigitized;// 数字化时间  
     private String ComponentsConfiguration;// 图像构造（多指色彩组合方案）  
     private String CompressedBitsPerPixel;// (BPP)压缩时每像素色彩位 指压缩程度  
     private String ExposureBiasValue;// 曝光补偿。  
     private String MaxApertureValue;// 最大光圈  
     private String MeteringMode;// 测光方式，平均式测光、中央重点测光、点测光等。  
     private String Lightsource;// 光源 指白平衡设置  
     private String Flash;// 是否使用闪光灯。  
     private String FocalLength;// 焦距，一般显示镜头物理焦距，有些软件可以定义一个系数，从而显示相当于35mm相机的焦距  
     private String MakerNote;// (User Comment)作者标记、说明、记录  
     private String FlashPixVersionFlashPix;// 版本 （个别机型支持）  
     private String ColorSpace;// 色域、色彩空间  
     private String ExifImageWidth;// (Pixel X Dimension)图像宽度 指横向像素数  
     private String ExifImageLength;// (Pixel Y Dimension)图像高度 指纵向像素数  
     private String Interoperability;// IFD通用性扩展项定义指针 和TIFF文件相关，具体含义不详  
     private String FileSource;// 源文件 Compression压缩比  
   
     public String getImageDescription() {  
         return ImageDescription;  
     }  
   
     public void setImageDescription(String imageDescription) {  
         ImageDescription = imageDescription;  
     }  
   
     public String getArtist() {  
         return Artist;  
     }  
   
     public void setArtist(String artist) {  
         Artist = artist;  
     }  
   
     public String getMake() {  
         return Make;  
     }  
   
     public void setMake(String make) {  
         Make = make;  
     }  
   
     public String getModel() {  
         return Model;  
     }  
   
     public void setModel(String model) {  
         Model = model;  
     }  
   
     public String getOrientation() {  
         return Orientation;  
     }  
   
     public void setOrientation(String orientation) {  
         Orientation = orientation;  
     }  
   
     public String getXResolution() {  
         return XResolution;  
     }  
   
     public void setXResolution(String xResolution) {  
         XResolution = xResolution;  
     }  
   
     public String getYResolution() {  
         return YResolution;  
     }  
   
     public void setYResolution(String yResolution) {  
         YResolution = yResolution;  
     }  
   
     public String getResolutionUnit() {  
         return ResolutionUnit;  
     }  
   
     public void setResolutionUnit(String resolutionUnit) {  
         ResolutionUnit = resolutionUnit;  
     }  
   
     public String getSoftware() {  
         return Software;  
     }  
   
     public void setSoftware(String software) {  
         Software = software;  
     }  
   
     public String getFirmware() {  
         return Firmware;  
     }  
   
     public void setFirmware(String firmware) {  
         Firmware = firmware;  
     }  
   
     public String getDateTime() {  
         return DateTime;  
     }  
   
     public void setDateTime(String dateTime) {  
         DateTime = dateTime;  
     }  
   
     public String getYCbCrPositioning() {  
         return YCbCrPositioning;  
     }  
   
     public void setYCbCrPositioning(String yCbCrPositioning) {  
         YCbCrPositioning = yCbCrPositioning;  
     }  
   
     public String getExifOffsetExif() {  
         return ExifOffsetExif;  
     }  
   
     public void setExifOffsetExif(String exifOffsetExif) {  
         ExifOffsetExif = exifOffsetExif;  
     }  
   
     public String getExposureTime() {  
         return ExposureTime;  
     }  
   
     public void setExposureTime(String exposureTime) {  
         ExposureTime = exposureTime;  
     }  
   
     public String getFNumber() {  
         return FNumber;  
     }  
   
     public void setFNumber(String fNumber) {  
         FNumber = fNumber;  
     }  
   
     public String getExposureProgram() {  
         return ExposureProgram;  
     }  
   
     public void setExposureProgram(String exposureProgram) {  
         ExposureProgram = exposureProgram;  
     }  
   
     public String getIsoSpeedRatings() {  
         return IsoSpeedRatings;  
     }  
   
     public void setIsoSpeedRatings(String isoSpeedRatings) {  
         IsoSpeedRatings = isoSpeedRatings;  
     }  
   
     public String getExifVersion() {  
         return ExifVersion;  
     }  
   
     public void setExifVersion(String exifVersion) {  
         ExifVersion = exifVersion;  
     }  
   
     public String getDateTimeOriginal() {  
         return DateTimeOriginal;  
     }  
   
     public void setDateTimeOriginal(String dateTimeOriginal) {  
         DateTimeOriginal = dateTimeOriginal;  
     }  
   
     public String getDateTimeDigitized() {  
         return DateTimeDigitized;  
     }  
   
     public void setDateTimeDigitized(String dateTimeDigitized) {  
         DateTimeDigitized = dateTimeDigitized;  
     }  
   
     public String getComponentsConfiguration() {  
         return ComponentsConfiguration;  
     }  
   
     public void setComponentsConfiguration(String componentsConfiguration) {  
         ComponentsConfiguration = componentsConfiguration;  
     }  
   
     public String getCompressedBitsPerPixel() {  
         return CompressedBitsPerPixel;  
     }  
   
     public void setCompressedBitsPerPixel(String compressedBitsPerPixel) {  
         CompressedBitsPerPixel = compressedBitsPerPixel;  
     }  
   
     public String getExposureBiasValue() {  
         return ExposureBiasValue;  
     }  
   
     public void setExposureBiasValue(String exposureBiasValue) {  
         ExposureBiasValue = exposureBiasValue;  
     }  
   
     public String getMaxApertureValue() {  
         return MaxApertureValue;  
     }  
   
     public void setMaxApertureValue(String maxApertureValue) {  
         MaxApertureValue = maxApertureValue;  
     }  
   
     public String getMeteringMode() {  
         return MeteringMode;  
     }  
   
     public void setMeteringMode(String meteringMode) {  
         MeteringMode = meteringMode;  
     }  
   
     public String getLightsource() {  
         return Lightsource;  
     }  
   
     public void setLightsource(String lightsource) {  
         Lightsource = lightsource;  
     }  
   
     public String getFlash() {  
         return Flash;  
     }  
   
     public void setFlash(String flash) {  
         Flash = flash;  
     }  
   
     public String getFocalLength() {  
         return FocalLength;  
     }  
   
     public void setFocalLength(String focalLength) {  
         FocalLength = focalLength;  
     }  
   
     public String getMakerNote() {  
         return MakerNote;  
     }  
   
     public void setMakerNote(String makerNote) {  
         MakerNote = makerNote;  
     }  
   
     public String getFlashPixVersionFlashPix() {  
         return FlashPixVersionFlashPix;  
     }  
   
     public void setFlashPixVersionFlashPix(String flashPixVersionFlashPix) {  
         FlashPixVersionFlashPix = flashPixVersionFlashPix;  
     }  
   
     public String getColorSpace() {  
         return ColorSpace;  
     }  
   
     public void setColorSpace(String colorSpace) {  
         ColorSpace = colorSpace;  
     }  
   
     public String getExifImageWidth() {  
         return ExifImageWidth;  
     }  
   
     public void setExifImageWidth(String exifImageWidth) {  
         ExifImageWidth = exifImageWidth;  
     }  
   
     public String getExifImageLength() {  
         return ExifImageLength;  
     }  
   
     public void setExifImageLength(String exifImageLength) {  
         ExifImageLength = exifImageLength;  
     }  
   
     public String getInteroperability() {  
         return Interoperability;  
     }  
   
     public void setInteroperability(String interoperability) {  
         Interoperability = interoperability;  
     }  
   
     public String getFileSource() {  
         return FileSource;  
     }  
   
     public void setFileSource(String fileSource) {  
         FileSource = fileSource;  
     }  
   
 }  

图片文件对象：

    Java代码   
    
  
 import java.io.File;  
 import java.io.Serializable;  
   
 /** 
  * 图片文件信息 
  *  
  * @author  
  * @since 2010-5-19 
  */  
 public class ImageFile implements Serializable {  
   
     private static final long serialVersionUID = -337911125594555523L;  
   
     /** 
      * 图片宽，单位:px 
      */  
     private double width;  
   
     /** 
      * 图片高，单位:px 
      */  
     private double height;  
   
     /** 
      * 图片大小，单位:byte 
      */  
     private double size;  
   
     /** 
      * 图片类型 
      */  
     private ImageType type;  
   
     /** 
      * 图片文件 
      */  
     private File file;  
   
     /** 
      * 图片EXIF信息 
      */  
     private ImageExif exif;  
   
     public double getWidth() {  
         return width;  
     }  
   
     public void setWidth(double width) {  
         this.width = width;  
     }  
   
     public double getHeight() {  
         return height;  
     }  
   
     public void setHeight(double height) {  
         this.height = height;  
     }  
   
     public double getSize() {  
         return size;  
     }  
   
     public void setSize(double size) {  
         this.size = size;  
     }  
   
     public ImageType getType() {  
         return type;  
     }  
   
     public void setType(ImageType type) {  
         this.type = type;  
     }  
   
     public File getFile() {  
         return file;  
     }  
   
     public void setFile(File file) {  
         this.file = file;  
     }  
   
     public ImageExif getExif() {  
         return exif;  
     }  
   
     public void setExif(ImageExif exif) {  
         this.exif = exif;  
     }  
   
 }  

    Java代码   
    
  
 import java.awt.Graphics;  
 import java.awt.Graphics2D;  
 import java.awt.Image;  
 import java.awt.RenderingHints;  
 import java.awt.Toolkit;  
 import java.awt.image.BufferedImage;  
 import java.awt.image.CropImageFilter;  
 import java.awt.image.FilteredImageSource;  
 import java.awt.image.ImageFilter;  
 import java.awt.image.RenderedImage;  
 import java.io.BufferedInputStream;  
 import java.io.ByteArrayInputStream;  
 import java.io.ByteArrayOutputStream;  
 import java.io.File;  
 import java.io.FileInputStream;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.InputStream;  
 import java.lang.reflect.Method;  
 import java.util.Iterator;  
   
 import javax.imageio.ImageIO;  
 import javax.imageio.ImageReader;  
 import javax.imageio.stream.MemoryCacheImageInputStream;  
   
 import magick.MagickImage;  
   
 import org.apache.commons.lang.StringUtils;  
 import com.sun.image.codec.jpeg.JPEGCodec;  
 import com.sun.image.codec.jpeg.JPEGEncodeParam;  
 import com.sun.image.codec.jpeg.JPEGImageEncoder;  
 import com.sun.imageio.plugins.bmp.BMPImageReader;  
 import com.sun.imageio.plugins.gif.GIFImageReader;  
 import com.sun.imageio.plugins.jpeg.JPEGImageReader;  
 import com.sun.imageio.plugins.png.PNGImageReader;  
 import com.sun.imageio.plugins.wbmp.WBMPImageReader;  
   
   
 /** 
  * 使用 imageio 实现的图片处理工具 
  *  
  * @author 
  * @since 2010-7-14 
  */  
 public class ImageIOUtil {  
   
     /** 
      * 是否是合法图片 
      *  
      * @param suffix 
      *            图片文件后缀 
      * @param imageContent 
      *            图片内容 
      * @return 
      */  
     public static boolean isImage(byte[] imageContent) {  
         return isImage(null, imageContent);  
     }  
   
     /** 
      * 是否是合法图片 
      *  
      * @param imageContent 
      *            图片内容 
      * @return 
      */  
     public static boolean isImage(String suffix, byte[] imageContent) {  
         if (imageContent == null || imageContent.length == 0) {  
             return false;  
         }  
         Image img = null;  
         InputStream is = null;  
         try {  
             is = new ByteArrayInputStream(imageContent);  
             img = ImageIO.read(is);  
             if (img == null || img.getWidth(null) <= 0  
                     || img.getHeight(null) <= 0) {  
                 return false;  
             }  
             return true;  
         } catch (Exception e) {  
             return false;  
         } finally {  
             if (is != null) {  
                 try {  
                     is.close();  
                 } catch (IOException e) {  
                 }  
             }  
         }  
     }  
   
     /** 
      * 是否是合法图片 
      *  
      * @param imageFullPath 
      *            图片本地绝对路径 
      * @return 
      */  
     public static boolean isImage(String localImagePath) {  
         File imgFile = new File(localImagePath);  
         if (!imgFile.isFile()) {  
             return false;  
         }  
         Image img;  
         try {  
             img = ImageIO.read(imgFile);  
             if (imgFile.length() == 0 || img == null || img.getWidth(null) <= 0  
                     || img.getHeight(null) <= 0) {  
                 return false;  
             }  
             return true;  
         } catch (Exception e) {  
             return false;  
         }  
     }  
   
     /** 
      * 根据要求的坐标截取图片 
      *  
      * @param source 
      * @param x 
      * @param y 
      * @param width 
      * @param height 
      */  
     public static void cropPart(String imageFullPath, int x, int y, int width,  
             int height) throws RuntimeException {  
         Image img = null;  
         ImageFilter cropFilter = null;  
         BufferedImage bi = null;  
         try {  
             bi = ImageIO.read(new File(imageFullPath));  
             if (bi == null) {  
                 throw new RuntimeException("ImageIO.read return null");  
             }  
         } catch (Exception e) {  
             throw new RuntimeException(String.format("read image fail, src=",  
                     imageFullPath));  
         }  
         int srcW = bi.getWidth();  
         int srcH = bi.getHeight();  
         if (srcW <= 0 || srcH <= 0) {  
             throw new RuntimeException(String.format("invalid image, src=",  
                     imageFullPath));  
         }  
         // 异常的图片参数  
         if (x >= srcW || y >= srcH) {  
             throw new RuntimeException(  
                     String  
                             .format(  
                                     "cropPart fail, point (x=%s,y=%s) not in the image(width=%s,height=%s)",  
                                     x, y, srcW, srcH));  
         }  
         width = Math.min(width, srcW - x);  
         height = Math.min(height, srcH - y);  
         try {  
             Image image = bi.getScaledInstance(srcW, srcH, Image.SCALE_DEFAULT);  
             cropFilter = new CropImageFilter(x, y, width, height);  
             img = Toolkit.getDefaultToolkit().createImage(  
                     new FilteredImageSource(image.getSource(), cropFilter));  
             BufferedImage tag = new BufferedImage(width, height,  
                     BufferedImage.TYPE_INT_RGB);  
             Graphics2D g = (Graphics2D) tag.getGraphics();  
             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,  
                     RenderingHints.VALUE_INTERPOLATION_BILINEAR);  
             g.drawImage(img, 0, 0, null);  
             g.dispose();  
             ImageIO.write(tag, "jpg", new File(imageFullPath));  
         } catch (Exception e) {  
             throw new RuntimeException("process image error, src="  
                     + imageFullPath, e);  
         }  
     }  
   
     /** 
      * 将imageFullPath指定的图片进行等比缩放，最长的边为<t>maxEdgeLength</t> 
      *  
      * @param imageFullPath 
      *            ：需要裁剪的图片绝对路径 
      * @param maxEdgeLength 
      *            : 边长 
      * @return 
      */  
     public static boolean resizeImage(String imageFullPath, int maxEdgeLength)  
             throws Exception {  
         File file = new File(imageFullPath);  
         if (!file.exists()) {  
             return false;  
         }  
         Image img = ImageIO.read(file);  
         // 判断图片格式是否正确  
         if (img == null || img.getWidth(null) <= 0 || img.getHeight(null) <= 0) {  
             return false;  
         }  
         int width = img.getWidth(null);  
         int height = img.getHeight(null);  
   
         boolean isWidthLonger = width > height ? true : false;  
   
         // 得到调整后的尺寸及缩小的比例,如果{width,height}都小于等于maxEdgeLength，直接返回  
         if (width > maxEdgeLength || height > maxEdgeLength) {  
             double ratio;  
   
             if (isWidthLonger) {  
                 ratio = ((double) maxEdgeLength) / width;  
                 width = maxEdgeLength;  
                 height = ((Double) Math.floor(ratio * height)).intValue();  
             } else {  
                 ratio = ((double) maxEdgeLength) / height;  
                 width = ((Double) Math.floor(ratio * width)).intValue();  
                 height = maxEdgeLength;  
             }  
         } else {  
             return true;  
         }  
         FileOutputStream out = null;  
         try {  
             BufferedImage tag = new BufferedImage((int) width, (int) height,  
                     BufferedImage.TYPE_INT_RGB);  
             tag.getGraphics().drawImage(  
                     img.getScaledInstance(width, height, Image.SCALE_SMOOTH),  
                     0, 0, null);  
             out = new FileOutputStream(imageFullPath);  
             ImageIO.write(tag, "jpg", out);  
         } catch (Exception e) {  
             throw new RuntimeException("resize image error, img="  
                     + imageFullPath, e);  
         } finally {  
             if (out != null) {  
                 out.close();  
             }  
         }  
         return true;  
     }  
   
     /** 
      * 对imageFullPath 指定的文件按要求的质量quality进行压缩(gif将不会进行压缩)。quality的范围是(0-100) 
      *  
      * @param imageFullPath 
      *            文件的绝对路径 
      * @param quality 
      *            压缩的质量,范围是(0-100) 
      * @param maxFileSize 
      *            文件超过该大小才进行质量有损压缩,单位:byte 
      * @return 文件大小,单位:byte 
      */  
     public static int compressImage(String imageFullPath, int quality,  
             long maxFileSize) {  
         // 1. entry validation  
         if (StringUtil.isEmpty(imageFullPath) || quality < 0 || quality > 100) {  
             throw new RuntimeException("invalid parameters, src="  
                     + imageFullPath + ",quality=" + quality);  
         }  
         File img = new File(imageFullPath);  
         if (!img.isFile()) {  
             throw new RuntimeException("file not exists, src=" + imageFullPath);  
         }  
         if (img.length() <= maxFileSize) {  
             return (int) img.length();  
         }  
   
         // 2. compress  
         FileOutputStream out = null;  
         try {  
             // Retrieve jpg image to be compressed  
             RenderedImage rendImage = ImageIO.read(new File(imageFullPath));  
             if (rendImage == null || rendImage.getWidth() <= 0  
                     || rendImage.getHeight() <= 0) {  
                 throw new RuntimeException("file is not an image, src="  
                         + imageFullPath);  
             }  
             out = new FileOutputStream(img);  
             BufferedImage tag = new BufferedImage(rendImage.getWidth(),  
                     rendImage.getHeight(), BufferedImage.TYPE_INT_RGB);  
             tag.getGraphics().drawImage((Image) rendImage, 0, 0,  
                     rendImage.getWidth(), rendImage.getHeight(), null);  
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);  
             JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(tag);  
             jep.setQuality(quality / 100f, true);  
             encoder.encode(tag, jep);  
         } catch (Exception e) {  
             throw new RuntimeException("compressImage fail, src="  
                     + imageFullPath, e);  
         } finally {  
             if (out != null) {  
                 try {  
                     out.close();  
                 } catch (IOException e) {  
                 }  
             }  
         }  
         return (int) new File(imageFullPath).length();  
     }  
   
     /** 
      * 获取图片信息,包括宽／高／大小／类型，如果取不到会抛异常 
      *  
      * @param imageFullPath 
      * @return 
      * @throws Exception 
      */  
     public static ImageFile getImageInfo(String imageFullPath) throws Exception {  
         return getImageInfo(imageFullPath, false);  
     }  
   
     /** 
      * (本方法暂不支持)获取图片信息+EXIF信息,如果非图片格式会抛异常 
      *  
      * @param localImagePath 
      *            本地图片路径 
      * @param isReadExif 
      *            是否需要读取exif信息 
      * @return 
      * @throws Exception 
      */  
     @SuppressWarnings("unchecked")  
     public static ImageFile getImageInfo(String localImagePath,  
             boolean isReadExif) {  
         File imgFile = new File(localImagePath);  
         if (!imgFile.isFile()) {  
             throw new RuntimeException("file not exists or not a file, file="  
                     + localImagePath);  
         }  
         Image img;  
         try {  
             img = ImageIO.read(imgFile);  
             if (imgFile.length() == 0 || img == null || img.getWidth(null) <= 0  
                     || img.getHeight(null) <= 0) {  
                 throw new RuntimeException(  
                         "get image's size/width/height error, file="  
                                 + localImagePath);  
             }  
         } catch (IOException e) {  
             throw new RuntimeException(  
                     "get image's size/width/height error, file="  
                             + localImagePath);  
         }  
         ImageFile imageFile = new ImageFile();  
         imageFile.setWidth(img.getWidth(null));  
         imageFile.setHeight(img.getHeight(null));  
         imageFile.setSize(imgFile.length());  
         imageFile.setFile(imgFile);  
   
         FileInputStream fis = null;  
         BufferedInputStream buff = null;  
         int leng;  
         byte[] mapObj;  
         try {  
             fis = new FileInputStream(imgFile);  
             leng = fis.available();  
             buff = new BufferedInputStream(fis);  
             mapObj = new byte[leng];  
             buff.read(mapObj, 0, leng);  
         } catch (IOException e) {  
             throw new RuntimeException("read image file stream error, file="  
                     + localImagePath);  
         }  
   
         String type = null;  
         ByteArrayInputStream bais = null;  
         MemoryCacheImageInputStream mcis = null;  
         try {  
             bais = new ByteArrayInputStream(mapObj);  
             mcis = new MemoryCacheImageInputStream(bais);  
             Iterator itr = ImageIO.getImageReaders(mcis);  
             while (itr.hasNext()) {  
                 ImageReader reader = (ImageReader) itr.next();  
                 if (reader instanceof GIFImageReader) {  
                     type = "gif";  
                 } else if (reader instanceof JPEGImageReader) {  
                     type = "jpg";  
                 } else if (reader instanceof PNGImageReader) {  
                     type = "png";  
                 } else if (reader instanceof BMPImageReader  
                         || reader instanceof WBMPImageReader) {  
                     type = "bmp";  
                 }  
             }  
             if (type != null) {  
                 imageFile.setType(ImageType.valueOf(type));  
                 if (isReadExif) {  
                     // TODO read exif information  
                 }  
                 return imageFile;  
             }  
         } finally {  
             if (bais != null) {  
                 try {  
                     bais.close();  
                 } catch (IOException ioe) {  
                 }  
             }  
             if (mcis != null) {  
                 try {  
                     mcis.close();  
                 } catch (IOException ioe) {  
                 }  
             }  
             if (buff != null) {  
                 try {  
                     buff.close();  
                 } catch (IOException ioe) {  
                 }  
             }  
             if (fis != null) {  
                 try {  
                     fis.close();  
                 } catch (IOException ioe) {  
                 }  
             }  
         }  
         return null;  
     }  
   
     private static Method[] exifMethods = ImageExif.class.getMethods();  
   
     private static ImageExif readImageExif(MagickImage image) {  
         ImageExif exif = new ImageExif();  
         if (image == null) {  
             return exif;  
         }  
         try {  
             for (Method method : exifMethods) {  
                 if ("set".equals(method.getName().substring(0, 3))) {  
                     if (method.getName().length() > 3) {  
                         method.invoke(exif, image.getImageAttribute("EXIF:"  
                                 + method.getName().substring(3)));  
                     }  
                 }  
             }  
   
         } catch (Exception e) {  
             throw new RuntimeException("read image exif error", e);  
         }  
         return exif;  
     }  
   
     /** 
      * 给图片打水印(本地图片会被替换成有水印的图片)，如果图片宽高要小于水印宽高+x或y，则不会打水印 
      *  
      * @param localImage 
      *            源图的本地绝对路径 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     public static boolean mask(String localImage, String markImage,  
             int maskType, int x, int y) throws Exception {  
         return mask(localImage, localImage, markImage, maskType, x, y);  
     }  
   
     /** 
      * 给图片打水印(生成目标图片会带水印)，如果图片宽高要小于水印宽高+endX或endY，则不会打水印 
      *  
      * @param imageBytes 
      *            源图的byte数组 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 处理后图片的byte数组 
      * @throws Exception 
      */  
     public static byte[] mask(byte[] imageBytes, String markImage,  
             int maskType, int x, int y) throws Exception {  
         File srcTmp = File.createTempFile("ImageIOUtil", null);  
         Image src = ImageIO.read(new ByteArrayInputStream(imageBytes));  
         Image logo = ImageIO.read(new File(markImage));  
         maskCore(src, srcTmp, logo, maskType, x, y);  
         InputStream input = null;  
         ByteArrayOutputStream out = null;  
         try {  
             input = new FileInputStream(srcTmp);  
             out = new ByteArrayOutputStream(4096);  
             byte[] b = new byte[4096];  
             int n;  
             while ((n = input.read(b)) != -1) {  
                 out.write(b, 0, n);  
                 out.flush();  
             }  
             return out.toByteArray();  
         } finally {  
             if (input != null) {  
                 try {  
                     input.close();  
                 } catch (Exception e) {  
                 }  
             }  
             if (out != null) {  
                 try {  
                     out.close();  
                 } catch (Exception e) {  
                 }  
             }  
         }  
     }  
   
     /** 
      * 给图片打水印(生成目标图片会带水印)，如果图片宽高要小于水印宽高+x或y，则不会打水印 
      *  
      * @param localImage 
      *            源图的本地绝对路径 
      * @param destImage 
      *            目标图片的本地绝对路径 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     public static boolean mask(String localImage, String destImage,  
             String markImage, int maskType, int x, int y) throws Exception {  
         Image src = ImageIO.read(new File(localImage));  
         Image logo = ImageIO.read(new File(markImage));  
         File dest = new File(destImage);  
         return maskCore(src, dest, logo, maskType, x, y);  
     }  
   
     /** 
      * 打水印主逻辑 
      *  
      * @param src 
      *            源图 
      * @param dest 
      *            目标输出文件 
      * @param logo 
      *            水印 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param marginX 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param marginY 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     private static boolean maskCore(Image src, File dest, Image logo,  
             int maskType, int marginX, int marginY) throws Exception {  
         // 校验图片合法性  
         if (src == null || src.getWidth(null) <= 0 || src.getHeight(null) <= 0  
                 || dest == null || logo == null || src.getWidth(null) <= 0  
                 || src.getHeight(null) <= 0) {  
             return false;  
         }  
         int srcW = src.getWidth(null);  
         int srcH = src.getHeight(null);  
         int logoW = logo.getWidth(null);  
         int logoH = logo.getHeight(null);  
   
         int x = 0, y = 0;  
         switch (maskType) {  
         // 左下角  
         case 1:  
             x = marginX;  
             y = (int) (srcH - logoH - marginY);  
             break;  
         // 正中间  
         case 2:  
             x = (int) ((srcW - logoW) / 2);  
             y = (int) ((srcH - logoH) / 2);  
             break;  
         // 左上角  
         case 3:  
             x = marginX;  
             y = marginY;  
             break;  
         // 右上角  
         case 4:  
             x = (int) (srcW - logoW - marginX);  
             y = marginY;  
             break;  
         // 自定义  
         case 5:  
             x = marginX;  
             y = marginY;  
             break;  
         // 右下角  
         case 0:  
             // 其它值默认右下角  
         default:  
             x = (int) (srcW - logoW - marginX);  
             y = (int) (srcH - logoH - marginY);  
         }  
   
         // 校验水印是否全部落在图片中  
         if (x <= 0 || y <= 0 || x > srcW - logoW || y > srcH - logoH) {  
             return false;  
         }  
   
         FileOutputStream out = null;  
         try {  
             BufferedImage tag = new BufferedImage((int) srcW, (int) srcH,  
                     BufferedImage.TYPE_INT_RGB);  
             Graphics g = tag.getGraphics();  
             g.drawImage(src, 0, 0, srcW, srcH, null);  
             g.drawImage(logo, x, y, logoW, logoH, null);  
             out = new FileOutputStream(dest);  
             ImageIO.write(tag, "jpg", out);  
             g.dispose();  
         } catch (Exception e) {  
             throw new RuntimeException("resize image error", e);  
         } finally {  
             if (out != null) {  
                 out.close();  
             }  
         }  
         return true;  
     }  
 }  

上边的图片是要exif是需要使用JMagick获取所以如果有兴趣就需要同学安装，下面给出

JMagickUtil

    Java代码   
    
  
 import java.awt.Rectangle;  
 import java.io.File;  
 import java.lang.reflect.Method;  
   
 import magick.CompositeOperator;  
 import magick.ImageInfo;  
 import magick.MagickImage;  
   
 import org.apache.commons.lang.StringUtils;  
 import com.taobao.communitypsc.common.image.ImageExif;  
 import com.taobao.communitypsc.common.image.ImageFile;  
 import com.taobao.communitypsc.common.image.ImageType;  
   
 /** 
  * JMagick 处理图片 
  *  
  * @author  
  * @since 2010-5-20 
  */  
 public class JMagickUtil {  
   
     static {  
         System.setProperty("jmagick.systemclassloader", "no");  
     }  
   
     /** 
      * 是否是合法图片 
      *  
      * @param suffix 
      *            图片文件后缀 
      * @param imageContent 
      *            图片内容 
      * @return 
      */  
     public static boolean isImage(String suffix, byte[] imageContent) {  
         try {  
             MagickImage image = new MagickImage(new ImageInfo(suffix),  
                     imageContent);  
             if (image == null || image.getDimension().getWidth() <= 0) {  
                 return false;  
             }  
         } catch (Exception e) {  
             return false;  
         }  
         return true;  
     }  
   
     /** 
      * 是否是合法图片 
      *  
      * @param imageFullPath 
      *            图片本地绝对路径 
      * @return 
      */  
     public static boolean isImage(String localImagePath) {  
         if (localImagePath == null || !new File(localImagePath).isFile()) {  
             return false;  
         }  
         try {  
             MagickImage image = new MagickImage(new ImageInfo(localImagePath));  
             if (image.getDimension() == null  
                     || image.getDimension().getWidth() <= 0) {  
                 return false;  
             }  
         } catch (Exception e) {  
             return false;  
         }  
         return true;  
     }  
   
     /** 
      * 根据要求的坐标截取图片 
      *  
      * @param source 
      * @param x 
      * @param y 
      * @param width 
      * @param height 
      */  
     public static void cropPart(String imageFullPath, int x, int y, int width,  
             int height) throws Exception {  
         MagickImage image = null;  
         ImageInfo info = null;  
         // 取得原文件  
         try {  
             info = new ImageInfo(imageFullPath);  
             // 获取图片  
             image = new MagickImage(info);  
             // 原始尺寸  
             int beforeScaleX = image.getDimension().width;  
             int beforeScaleY = image.getDimension().height;  
   
             // 是否需要这个约束  
             int cropWidth = (x + width > beforeScaleX) ? (beforeScaleX - x)  
                     : width;  
             int cropHeight = (y + height > beforeScaleY) ? (beforeScaleY - y)  
                     : height;  
   
             MagickImage small = image.cropImage(new Rectangle(x, y, cropWidth,  
                     cropHeight));  
             small.setFileName(imageFullPath);  
             small.writeImage(new ImageInfo());  
             small.destroyImages();  
         } finally {  
             if (image != null) {  
                 image.destroyImages();  
             }  
         }  
     }  
   
     /** 
      * 将imageFullPath指定的图片进行等比缩放，最长的边为<t>maxEdgeLength</t> 
      *  
      * @param imageFullPath 
      *            ：需要裁剪的图片绝对路径 
      * @param edgeLength 
      *            : 边长 
      * @return 
      */  
     public static boolean resizeImage(String imageFullPath, int maxEdgeLength)  
             throws Exception {  
         // 取得原文件  
         MagickImage image = new MagickImage(new ImageInfo(imageFullPath));  
         String suffix = image.getImageFormat();  
         if (suffix.equalsIgnoreCase("gif")) {  
             image = extractFirstFrame(image);  
         }  
         // 原始尺寸  
         int width = image.getDimension().width;  
         int height = image.getDimension().height;  
   
         boolean isWidthLonger = width > height ? true : false;  
   
         // 得到调整后的尺寸及缩小的比例,如果{width,height}都小于等于maxEdgeLength，直接返回  
         if (width > maxEdgeLength || height > maxEdgeLength) {  
             double ratio;  
   
             if (isWidthLonger) {  
                 ratio = ((double) maxEdgeLength) / width;  
                 width = maxEdgeLength;  
                 height = ((Double) Math.floor(ratio * height)).intValue();  
             } else {  
                 ratio = ((double) maxEdgeLength) / height;  
                 width = ((Double) Math.floor(ratio * width)).intValue();  
                 height = maxEdgeLength;  
             }  
   
             MagickImage small = image.scaleImage(width, height);  
             small.setFileName(imageFullPath);  
             small.writeImage(new ImageInfo());  
             small.destroyImages();  
         }  
         return true;  
     }  
   
     /** 
      * 截取第一帧 
      *  
      * @param image 
      *            gif动画 
      * @return 
      */  
     private static MagickImage extractFirstFrame(MagickImage image)  
             throws Exception {  
         MagickImage[] frames = image.breakFrames();  
         return frames[0];  
     }  
   
     /** 
      * 对imageFullPath 指定的文件按要求的质量quality进行压缩(gif将不会进行压缩)。quality的范围是(0-100) 
      *  
      * @param imageFullPath 
      *            文件的绝对路径 
      * @param quality 
      *            压缩的质量,范围是(0-100) 
      * @param maxFileSize 
      *            文件超过该大小才进行质量有损压缩,单位:byte 
      * @return 文件大小,单位:byte 
      */  
     public static int compressImage(String imageFullPath, int quality,  
             long maxFileSize) throws Exception {  
         // 1. entry validation  
         if (StringUtil.isEmpty(imageFullPath) || quality <= 0 || quality >= 100) {  
             return -1;  
         }  
         int i = imageFullPath.lastIndexOf(".");  
         if (i < 0) {  
             return -1;  
         }  
   
         // 2. compress  
         String fileName = imageFullPath.substring(0, i);  
         File fileSrc = new File(imageFullPath);  
   
         ImageInfo info = null;  
         MagickImage image = null;  
         try {  
             info = new ImageInfo(imageFullPath);  
             image = new MagickImage(info);  
   
             if (null == image || image.getDimension() == null  
                     || image.getDimension().getWidth() <= 0) {  
                 return -1;  
             }  
   
             String type = image.getImageFormat();  
   
             if ("gif".equalsIgnoreCase(type)) {  
                 // 解决 trojan.giframe 病毒 问题，gif 也通过MagickImage另存一下图片  
                 fileName = fileName + ".gif";  
                 image.setFileName(fileName);  
                 image.writeImage(new ImageInfo());  
             } else {  
                 if (fileSrc.length() > maxFileSize) {// 大于指定文件大小,进行压缩  
                     // 调整图片品质 最佳为40~50  
                     info.setQuality(quality);  
                     image.profileImage("*", null);  
                     image.setImageAttribute("comment", null);  
                     image.setImageAttribute("JPEG-Sampling-factors", null);  
                     image.setFileName(imageFullPath);  
                     image.writeImage(info);  
                 }  
             }  
             return (int) fileSrc.length();  
         } finally {  
             if (image != null) {  
                 image.destroyImages();  
             }  
         }  
     }  
   
     /** 
      * 获取图片信息,包括宽／高／大小／类型，如果取不到会抛异常 
      *  
      * @param imageFullPath 
      * @return 
      * @throws Exception 
      */  
     public static ImageFile getImageInfo(String imageFullPath) throws Exception {  
         return getImageInfo(imageFullPath, false);  
     }  
   
     /** 
      * 获取图片信息+EXIF信息,如果非图片格式会抛异常 
      *  
      * @param localImagePath 
      *            本地图片路径 
      * @param isReadExif 
      *            是否需要读取exif信息 
      * @return 
      * @throws Exception 
      */  
     public static ImageFile getImageInfo(String localImagePath,  
             boolean isReadExif) throws Exception {  
         File file = new File(localImagePath);  
         if (!file.isFile()) {  
             throw new Exception("file not exists or not a file, file="  
                     + localImagePath);  
         }  
         ImageFile imageFile = new ImageFile();  
         MagickImage image = new MagickImage(new ImageInfo(localImagePath));  
         if (image.getDimension() == null  
                 || image.getDimension().getWidth() <= 0) {  
             throw new Exception("get image's dimension error, file="  
                     + localImagePath);  
         }  
         imageFile.setFile(new File(localImagePath));  
         imageFile.setHeight(image.getDimension().getHeight());  
         imageFile.setWidth(image.getDimension().getWidth());  
         imageFile.setType(ImageType.toImageType(image.getImageFormat()));  
         imageFile.setSize(file.length());  
         if (isReadExif) {  
             imageFile.setExif(readImageExif(image));  
         }  
         return imageFile;  
     }  
   
     private static Method[] exifMethods = ImageExif.class.getMethods();  
   
     private static ImageExif readImageExif(MagickImage image) {  
         ImageExif exif = new ImageExif();  
         if (image == null) {  
             return exif;  
         }  
         try {  
             for (Method method : exifMethods) {  
                 if ("set".equals(method.getName().substring(0, 3))) {  
                     if (method.getName().length() > 3) {  
                         method.invoke(exif, image.getImageAttribute("EXIF:"  
                                 + method.getName().substring(3)));  
                     }  
                 }  
             }  
   
         } catch (Exception e) {  
             throw new RuntimeException("read image exif error", e);  
         }  
         return exif;  
     }  
   
     /** 
      * 给图片打水印(本地图片会被替换成有水印的图片)，如果图片宽高要小于水印宽高+x或y，则不会打水印 
      *  
      * @param localImage 
      *            源图的本地绝对路径 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     public static boolean mask(String localImage, String markImage,  
             int maskType, int x, int y) throws Exception {  
         return mask(localImage, localImage, markImage, maskType, x, y);  
     }  
   
     /** 
      * 给图片打水印(生成目标图片会带水印)，如果图片宽高要小于水印宽高+endX或endY，则不会打水印 
      *  
      * @param imageBytes 
      *            源图的byte数组 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 处理后图片的byte数组 
      * @throws Exception 
      */  
     public static byte[] mask(byte[] imageBytes, String markImage,  
             int maskType, int x, int y) throws Exception {  
         ImageInfo info = new ImageInfo();  
         MagickImage src = null;  
         MagickImage logo = null;  
         try {  
             src = new MagickImage(info, imageBytes);  
             logo = new MagickImage(new ImageInfo(markImage));  
             maskCore(src, src, info, logo, maskType, x, y);  
             return src.imageToBlob(info);  
         } finally {  
             if (src != null) {  
                 src.destroyImages();  
             }  
             if (logo != null) {  
                 logo.destroyImages();  
             }  
         }  
     }  
   
     /** 
      * 给图片打水印(生成目标图片会带水印)，如果图片宽高要小于水印宽高+x或y，则不会打水印 
      *  
      * @param localImage 
      *            源图的本地绝对路径 
      * @param destImage 
      *            目标图片的本地绝对路径 
      * @param markImage 
      *            水印图片的绝对路径 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param x 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param y 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     public static boolean mask(String localImage, String destImage,  
             String markImage, int maskType, int x, int y) throws Exception {  
         MagickImage src = null;  
         MagickImage logo = null;  
         MagickImage dest = null;  
         try {  
             ImageInfo info = new ImageInfo(localImage);  
             src = new MagickImage(info);  
             logo = new MagickImage(new ImageInfo(markImage));  
             dest = new MagickImage(info);  
             dest.setFileName(destImage);  
             return maskCore(src, dest, info, logo, maskType, x, y);  
         } finally {  
             if (src != null) {  
                 src.destroyImages();  
             }  
             if (logo != null) {  
                 logo.destroyImages();  
             }  
             if (dest != null) {  
                 dest.destroyImages();  
             }  
         }  
     }  
   
     /** 
      * 打水印主逻辑 
      *  
      * @param src 
      *            源图 
      * @param dest 
      *            目标图 
      * @param writeInfo 
      *            目标图的ImageInfo 
      * @param logo 
      *            水印 
      * @param maskType 
      *            0-右下角, 1-左下角, 2-正中间, 3-左上角, 4-右上角, 5-自定义 
      * @param marginX 
      *            离横向边间隔距离,如左对齐则左边距,右对齐则是右边距,居中传0,自定义则为左边距,单位:px 
      * @param marginY 
      *            离纵向边距离,如上对齐则上边距,下对齐则是下边距,居中传0,自定义则为上边距,单位:px 
      * @return 
      * @throws Exception 
      */  
     private static boolean maskCore(MagickImage src, MagickImage dest,  
             ImageInfo writeInfo, MagickImage logo, int maskType, int marginX,  
             int marginY) throws Exception {  
         // 校验图片合法性  
         if (src == null || src.getDimension() == null || dest == null  
                 || dest.getDimension() == null || logo == null  
                 || logo.getDimension() == null) {  
             return false;  
         }  
         // gif图片处理,gif多桢不处理,单桢则处理  
         String suffix = src.getImageFormat();  
         if (suffix.equalsIgnoreCase("gif")) {  
             MagickImage[] frames = src.breakFrames();  
             if (frames.length > 1) {  
                 return false;  
             }  
             src = frames[0];  
         }  
         double srcW = src.getDimension().getWidth();  
         double srcH = src.getDimension().getHeight();  
         double logoW = logo.getDimension().getWidth();  
         double logoH = logo.getDimension().getHeight();  
         if (srcW <= 0 || dest.getDimension().getWidth() <= 0 || logoW <= 0) {  
             return false;  
         }  
         int x = 0, y = 0;  
   
         switch (maskType) {  
         // 左下角  
         case 1:  
             x = marginX;  
             y = (int) (srcH - logoH - marginY);  
             break;  
         // 正中间  
         case 2:  
             x = (int) ((srcW - logoW) / 2);  
             y = (int) ((srcH - logoH) / 2);  
             break;  
         // 左上角  
         case 3:  
             x = marginX;  
             y = marginY;  
             break;  
         // 右上角  
         case 4:  
             x = (int) (srcW - logoW - marginX);  
             y = marginY;  
             break;  
         // 自定义  
         case 5:  
             x = marginX;  
             y = marginY;  
             break;  
         // 右下角  
         case 0:  
             // 其它值默认右下角  
         default:  
             x = (int) (srcW - logoW - marginX);  
             y = (int) (srcH - logoH - marginY);  
         }  
   
         // 校验水印是否全部落在图片中  
         if (x <= 0 || y <= 0 || x > srcW - logoW || y > srcH - logoH) {  
             return false;  
         }  
   
         dest.compositeImage(CompositeOperator.AtopCompositeOp, logo, x, y);  
         dest.writeImage(writeInfo);  
         return true;  
     }  
 }  