java关于图片处理修改图片大小

最近做了一个关于图片浏览的内容。因为图片都是一些证件的资料的扫描件所以比较大，对系统的影响也是非常之大的，有很大可能直接把系统干死。那么我是这么处理的，给大家分享一下。如果大家有好的方案的话一定要早点告诉我。

需求简单介绍：

上传文件是压缩包，但是到查看资料的时候压缩包可下载本地看，同时也可以在系统中直接在线浏览。

设计方案

　　

　　

1 营业部用户上传图片文件压缩包文件到综合业务系统tomcat服务器，系统在tomcat服务器将压缩文件解压到系统临时目录。

2 系统分析解压的图片文件（文件名上有分类和序号），按照分类和顺序将文件名存入到数据库表中。存入数据库的文件名带有路径。

3 将解压的文件和压缩包按照规定的路径上传到FTP服务器中。

4 FTP服务器同时是一台tomcat服务器，图片的目录在tomcat服务器的webapps目录下。

5 图片的路径命名方式：

webapps/imageserver/年(如2014)/月（如05）/日（如19）/16位唯一随机码/压缩包和解压文件

6 信审部查看图片文件和下载压缩包时，直接通过URL访问。

7 文件服务器不另外设置权限访问控制，所有访问控制通过16位唯一随机码控制，只有知道了16位唯一随机码，才能访问到图片文件和压缩包。

8 为了保证访问速度，单个图片文件最好控制在1M一下（我们可以推荐用户使用较低分辨率的扫描文件）。

9 如果图片访问量较大，需要购买硬件来升级文件服务器，例如采用NAS存储，升级带宽等。

实现步骤：

　　1：上传压缩包：解压到本地临时目录，检测图片大小修改图片大小，上传到ftp。

　　2：读取对应的的数据进行浏览。

这些相信大家都会，我下面贴出一个修改图片大小的工具类，方便我自己记忆，如果对大家有帮助也可以参考。

这个图片处理机制效率实在太慢，6个图片4-5秒，查了很多试了很多也没找到合适方法，暂且就用这个吧。如果有好的方法还望大家多多指教。

package com.minxinloan.black.web.utils;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.ImageIO;  

import org.apache.log4j.Logger;
//
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
//
//import com.sun.media.jai.codecimpl.JPEGCodec;
//import com.sun.media.jai.codecimpl.JPEGImageEncoder;

public class ImagesUtils {  

    private final static Logger log = Logger.getLogger(ImagesUtils.class);
    //图片允许的最大大小
    public static final int IMAGEMAXSIZE = 1024*1024;
    // 图片宽和高的最大尺寸
    public static final int IMAGEMAXBIG = 2000;
    // 图片宽和高的最小尺寸
    public static final int IMAGEMINBIG = 10;
    // 按原图大小生成新图
    public static final int CREATENEWIMAGETYPE_0 = 0;
    // 按指定的大小生成新图
    public static final int CREATENEWIMAGETYPE_1 = 1;
    // 按原图宽高比例生成新图-按指定的宽度
    public static final int CREATENEWIMAGETYPE_2 = 2;
    // 按原图宽高比例生成新图-按指定的高度
    public static final int CREATENEWIMAGETYPE_3 = 3;
    // 按原图宽高比例生成新图-按指定的宽和高中较大的尺寸
    public static final int CREATENEWIMAGETYPE_4 = 4;
    // 按原图宽高比例生成新图-按指定的宽和高中较小的尺寸
    public static final int CREATENEWIMAGETYPE_5 = 5;
    // 按原图宽高比例生成新图-按原图大小的90%进行修改
    public static final int CREATENEWIMAGETYPE_6 = 6;

    /**
     *
     * @param _file
     *            原图片
     * @param createType
     *            处理类型
     * @param newW
     *            新宽度
     * @param newH
     *            新高度
     * @return
     * @throws Exception
     */
    public static String createNewImage(File _file, int createType, int newW,
            int newH) throws Exception {
        if (_file == null)
            return null;
        String fileName = _file.getPath();
        if (fileName == null || "".equals(fileName)
                || fileName.lastIndexOf(".") == -1)
            return null;
        /*
         * else newFileName = "_" + newFileName;
         */  

        String outFileName = fileName.substring(0, fileName.lastIndexOf("."))
                + fileName.substring(fileName.lastIndexOf("."), fileName
                        .length());
        String fileExtName = fileName.substring(
                (fileName.lastIndexOf(".") + 1), fileName.length());
        if (newW < IMAGEMINBIG)
            newW = IMAGEMINBIG;
        else if (newW > IMAGEMAXBIG)
            newW = IMAGEMAXBIG;  

        if (newH < IMAGEMINBIG)
            newH = IMAGEMINBIG;
        else if (newH > IMAGEMAXBIG)
            newH = IMAGEMAXBIG;  

        // 得到原图信息
        if (!_file.exists() || !_file.isAbsolute() || !_file.isFile()
                || !checkImageFile(fileExtName))
            return null;
        Image src = ImageIO.read(_file);
        int w = src.getWidth(null);
        int h = src.getHeight(null);  

        // 确定目标图片的大小
        int nw = w;
        int nh = h;
        if (createType == CREATENEWIMAGETYPE_0)
            ;
        else if (createType == CREATENEWIMAGETYPE_1) {
            nw = newW;
            nh = newH;
        } else if (createType == CREATENEWIMAGETYPE_2) {
            nw = newW;
            nh = (int) ((double) h / (double) w * nw);
        } else if (createType == CREATENEWIMAGETYPE_3) {
            nh = newH;
            nw = (int) ((double) w / (double) h * nh);
        } else if (createType == CREATENEWIMAGETYPE_4) {
            if ((double) w / (double) h >= (double) newW / (double) newH) {
                nh = newH;
                nw = (int) ((double) w / (double) h * nh);
            } else {
                nw = newW;
                nh = (int) ((double) h / (double) w * nw);
            }
        } else if (createType == CREATENEWIMAGETYPE_5) {
            if ((double) w / (double) h <= (double) newW / (double) newH) {
                nh = newH;
                nw = (int) ((double) w / (double) h * nh);
            } else {
                nw = newW;
                nh = (int) ((double) h / (double) w * nw);
            }
        } else if(createType == CREATENEWIMAGETYPE_6){
//            nw = (int)(w*0.5);
//            nh = (int)(h*0.5);
            double proportion = (double)1700/(double)w;
            nw = (int)((double)w*proportion);
            nh = (int)((double)h*proportion);
        } 

        // 构造目标图片
        BufferedImage tag = new BufferedImage(nw, nh,
                BufferedImage.TYPE_INT_RGB);  

        // 得到目标图片输出流
        FileOutputStream out = new FileOutputStream(outFileName);  

        // 根据需求画出目标图片 方式1
        tag.getGraphics().drawImage(src, 0, 0, nw, nh, null);  

        // 将画好的目标图输出到输出流 方式1
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
        encoder.encode(tag);
        out.close();
        return outFileName;
    }  

    public static boolean checkImageFile(String extName) {  

        if ("jpg".equalsIgnoreCase(extName))
            return true;
        if ("gif".equalsIgnoreCase(extName))
            return true;
        if ("bmp".equalsIgnoreCase(extName))
            return true;
        if ("jpeg".equalsIgnoreCase(extName))
            return true;
        if ("png".equalsIgnoreCase(extName))
            return true;
        return false;
    }
    public static String checkImageFile2(String extName) {  

        if ("jpg".equalsIgnoreCase(extName))
            return "jpg";
        if ("gif".equalsIgnoreCase(extName))
            return "gif";
        if ("bmp".equalsIgnoreCase(extName))
            return "bmp";
        if ("jpeg".equalsIgnoreCase(extName))
            return "jpeg";
        if ("png".equalsIgnoreCase(extName))
            return "jpeg";
        return null;
    }  

    //递归修改图片大小
    public static void changeImgSize(String filePath,int createType)
    {
        try {
            File tempFile = new File(filePath);
            if(tempFile.length()>IMAGEMAXSIZE){
                System.out.println("sss");
                changeImgSize(createNewImage(tempFile, createType, 0, 0),createType);
            }
        } catch (Exception e) {
            log.error("the changeImgSize is failed . the message is "+e.getMessage());
        }
    }
    /**
     * 缩放图像（按比例缩放）
     * @param srcImageFile 源图像文件地址
     * @param result 缩放后的图像地址
     * @param scale 缩放比例
     * @param flag 缩放选择:true 放大; false 缩小;
     */
    public final static void scale(String srcImageFile,String type, String result) {
        try {

            File tempFile = new File(srcImageFile);
            if(tempFile.length()>IMAGEMAXSIZE){
                System.out.println("sss");
                BufferedImage src = ImageIO.read(tempFile); // 读入文件
                int width = src.getWidth(); // 得到源图宽
                int height = src.getHeight(); // 得到源图长

                double sc = (double)1700/(double)width;

                width = (int)((double)width * sc);
                height = (int)((double)height * sc);

                Image image = src.getScaledInstance(width, height,
                        Image.SCALE_DEFAULT);
                BufferedImage tag = new BufferedImage(width, height,
                        BufferedImage.TYPE_INT_RGB);
                Graphics g = tag.getGraphics();
                g.drawImage(image, 0, 0, null); // 绘制缩小后的图
                g.dispose();
                ImageIO.write(tag, type, new File(result));// 输出到文件流
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void changeImgSize(File file)
     {
         try {
                // 判断文件是否是文件，如果是文件，获取路径，并计数
                if (file.isFile()) {
                    String fileExtName = file.getName().substring(
                            (file.getName().lastIndexOf(".") + 1), file.getName().length());  

                    String temp = ImagesUtils.checkImageFile2(fileExtName);
                    if(temp!=null)
                        //scale(file.getAbsolutePath(),temp,file.getAbsolutePath());
                        ImagesUtils.changeImgSize(file.getAbsolutePath(), ImagesUtils.CREATENEWIMAGETYPE_6);
                } else {
                    // 如果是文件夹，声明一个数组放文件夹和他的子文件
                    File[] f = file.listFiles();
                    // 遍历文件件下的文件，并获取路径
                    for (File file2 : f) {
                        changeImgSize(file2);
                    }
                }
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
     }

    public static void main(String[] args) {

//
//        long start=System.currentTimeMillis();
//        String filePath = "C:\\Users\\zhangmi\\Desktop\\资料";
//        changeImgSize(new File(filePath));
//
//        long end=System.currentTimeMillis();
//        //在最好的一行加上:
//        System.out.println("执行耗时 : "+(end-start)/1000f+" 秒 ");

    }
}  

做已铭记