JAVA开发之压缩图片并打成ZIP文件

引用

  JAVA 获取网络图片或本地图片压缩后打成ZIP，但是获取网络流存在问题：每次获取图片流的大小不一样（图片不完整），以致无法构建图片进行压缩？ 

/*
释以下代码：即可获取完整图片流网络不稳定情况且网络流是顺序读取，所以获得前部份流，不需要关闭连接，只需要将用完的流关闭即可
*/
finally{
    if(httpCon != null)
    httpCon.disconnect();
}

package com.sunshine.monitor.comm.util.http;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Iterator;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;

import sun.net.www.protocol.ftp.FtpURLConnection;

/**
 * 获取网络图片
 *
 * @author OY
 */
public abstract class HttpHelpers {

    private static final String KEY = "file.encoding";

    private static final String ENCODING = "GBK";

    public static InputStream getInputStream(String url) throws Exception{
        URLConnection con = null;
        HttpURLConnection httpCon = null;
        FtpURLConnection ftpCon= null;
        try {
            System.setProperty(KEY, ENCODING);
            URL _url = new URL(url);
            con = _url.openConnection();
            con.setConnectTimeout(3000);
            con.setUseCaches(false);// 不缓存
            con.setDefaultUseCaches(false);
            if (con instanceof HttpURLConnection) {
                httpCon = (HttpURLConnection) con;
                httpCon.setInstanceFollowRedirects(true);
                //httpCon.setRequestProperty("Accept-Charset", "utf-8");
                if (httpCon.getResponseCode() >= 300) {
                    System.out.println("URL:" + url
                            + ",HTTP Request is not success, Response code is "
                            + httpCon.getResponseCode());
                } else {
                    return httpCon.getInputStream();
                }
            } else if(con instanceof FtpURLConnection){
                ftpCon = (FtpURLConnection)con;
                return ftpCon.getInputStream();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(httpCon != null)
                httpCon.disconnect();
        }
        return null;
    }

    public static void main(String[] args) {
        // 1图片本地存储大小
        OutputStream fout = null;
        InputStream input = null;
        try {
            fout = new FileOutputStream("F:" + File.separator + "1.jpg");
            input = getInputStream("http://192.168.1.200/t.jpg");
            byte[] buffer = new byte[1024];
            int count = 0 ;
            while((count=input.read(buffer)) != -1){
                fout.write(buffer, 0, count);
            }
            fout.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try {
                if(input != null) input.close();
                if(fout != null) fout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 2是否可以构建图片
        try {
            input = getInputStream("http://192.168.1.200/t.jpg");
            ImageInputStream iis = ImageIO.createImageInputStream(input);
            if(iis != null) {
                Iterator<ImageReader> it = ImageIO.getImageReaders(iis);
                if(!it.hasNext()){
                    System.out.println("流不完整或不是图片！");
                } else {
                    System.out.println(it.next().getFormatName());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

引用

图片压缩采用thumbnailator,可以按大小、按比例、按质量压缩并增加水印，API简单 

 package com.sunshine.monitor.comm.util.compress;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.imageio.ImageIO;

import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.geometry.Positions;

/**
 * 图片压缩:按大小、按比例压缩、按质量
 * 增加水印
 * @author OY
 *
 */
public abstract class CompressPictureTools {

    private static float QUALITY = 0.6f;

    /**
     * 按大小缩小
     *
     * @param file
     * @param width
     * @param height
     * @return
     * @throws Exception
     */
    public static byte[] compressOfSize(File file, int width, int height)
            throws Exception {
        byte[] bs = null;
        InputStream input = null;
        try {
            input = new FileInputStream(file);
            bs = compressOfSize(input, width, height);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bs;
    }

    /**
     * 按大小缩小
     *
     * @param input 原图
     * @param width 目标宽席
     * @param height 目标高度
     * @return
     * @throws Exception
     */
    public static byte[] compressOfSize(InputStream input, int width, int height)
            throws Exception {
        ByteArrayOutputStream output = null;
        try {
            output = new ByteArrayOutputStream();
            Thumbnails.of(input).size(width, height).toOutputStream(output);
            return output.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (output != null)
                    output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 按指定比例进行缩小和放大: percent=1不变 percent>1放大 percent<1缩小
     *
     * @param input 原图
     * @param percent 压缩比例
     * @return
     * @throws Exception
     */
    public static byte[] compressOfPercent(InputStream input, float percent)
            throws Exception {
        ByteArrayOutputStream output = null;
        try {
            output = new ByteArrayOutputStream();
            Thumbnails.of(input).scale(percent).toOutputStream(output);
            return output.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (output != null)
                    output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 按指定比例进行缩小和放大: percent=1不变 percent>1放大 percent<1缩小
     *
     * @param file 原图
     * @param percent 压缩比例
     */
    public static byte[] compressOfPercent(File file, float percent)
            throws Exception {
        byte[] bs = null;
        InputStream input = null;
        try {
            input = new FileInputStream(file);
            bs = compressOfPercent(input, percent);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bs;
    }

    /**
     * 按质量压缩:图片尺寸不变，压缩图片文件大小
     *
     * @param file 原图
     * @param quality
     *            =1为最高质量
     * @return
     * @throws Exception
     */
    public static byte[] compressOfQuality(File file, float quality)
            throws Exception {
        byte[] bs = null;
        InputStream input = null;
        try {
            input = new FileInputStream(file);
            bs = compressOfQuality(input, quality);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bs;
    }

    /**
     * 按质量压缩:图片尺寸不变，压缩图片文件大小
     *
     * @param input 原图
     * @param quality
     *            =1为最高质量
     * @return
     * @throws Exception
     */
    public static byte[] compressOfQuality(InputStream input, float quality)
            throws Exception {
        ByteArrayOutputStream output = null;
        try {
            output = new ByteArrayOutputStream();
            if(quality == 0){
                Thumbnails.of(input).scale(1f).outputQuality(QUALITY)
                .toOutputStream(output);
            } else {
                Thumbnails.of(input).scale(1f).outputQuality(quality)
                    .toOutputStream(output);
            }
            return output.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (output != null)
                    output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 图片右下角添加水印
     *
     * @param fromPic
     *            原图
     * @param markPic
     *            水印图
     * @param transparent
     *            透明度
     * @return
     * @throws Exception
     */
    public static byte[] waterMark(byte[] fromPic, InputStream markPic,
            float transparent) throws Exception {
        InputStream finput = null;
        ByteArrayOutputStream output = null;
        try {
            finput = new ByteArrayInputStream(fromPic);
            output = new ByteArrayOutputStream();
            Thumbnails
                    .of(finput)
                    .scale(1f)
                    .watermark(Positions.BOTTOM_RIGHT, ImageIO.read(markPic),
                            transparent).toOutputStream(output);
            return output.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (output != null)
                    output.close();
                if (finput != null)
                    finput.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 图片格式转换
     *
     * @param fromPic
     *            原图
     * @param picFormat
     *            格式 png,jpg...
     * @return
     * @throws Exception
     */
    public static byte[] transferPicFormat(byte[] fromPic, String picFormat)
            throws Exception {
        ByteArrayInputStream finput = null;
        ByteArrayOutputStream output = null;
        try {
            finput = new ByteArrayInputStream(fromPic);
            output = new ByteArrayOutputStream();
            Thumbnails.of(finput).outputFormat(picFormat)
                    .toOutputStream(output);
            return output.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (output != null)
                    output.close();
                if (finput != null)
                    finput.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

引用

因JDK1.7以下，不可以设置编码，以致中文乱码问题，未采用java.util.ZipOutputStream,而是Apache ant下的ZipOutputStream 

package com.sunshine.monitor.comm.util.compress;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipOutputStream;

import com.sunshine.monitor.comm.util.http.HttpHelpers;
/**
 * 图片压缩成ZIP,支持并发多线程;
 * java.util.ZipOutputStream中文乱码
 * 方法一、JDK1.7可以设置编码
 * 方法二、换成Apache ant
 * @author OY
 *
 */
public class PicturePackZipTools {

private static String DEFAULT_COMPRESS_ENCODE = "GBK";

    private static ZipOutputStream getZipStreamEncode(OutputStream output,
            String encode) {
        ZipOutputStream zipStream = new ZipOutputStream(output);
        if (encode == null || "".equals(encode)) {
            zipStream.setEncoding(DEFAULT_COMPRESS_ENCODE);
        } else {
            zipStream.setEncoding(encode);
        }
        return zipStream;
    }

    /**
     * 访问本地路径下的所有文件
     *
     * @param path
     * @return
     */
    public static List<File> loadFiles(String path) {
        List<File> list = null;
        try {
            File fold = new File(path);
            if (fold.isDirectory()) {
                File[] files = fold.listFiles();
                list = Arrays.asList(files);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 读取本地系统路径下的所有图片打成ZIP
     *
     * @param path
     * @param output
     * @param compress
     */
    public static void compressZip(String path, OutputStream output,
            String encode, boolean compress) {
        List<File> listfiles = null;
        ZipOutputStream zipStream = null;
        try {
            zipStream = getZipStreamEncode(output, encode);
            listfiles = loadFiles(path);
            for (File file : listfiles) {
                compressZip(file, zipStream, compress);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (zipStream != null) {
                    zipStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 读取网络图片打成打成ZIP
     * @param urls
     *            key = 图片名, value = 图片URL
     * @param output
     * @param encode 编码
     * @param compress 是否压缩
     */
    public static void compressZip(Map<String, String> urls,
            OutputStream output, String encode, boolean compress) {
        ZipOutputStream zipStream = null;
        try {
            zipStream = getZipStreamEncode(output, encode);
            Map<String, String> synUrls = Collections.synchronizedMap(urls);
            Set<Entry<String, String>> set = synUrls.entrySet();
            Iterator<Entry<String, String>> it = set.iterator();
            while (it.hasNext()) {
                Entry<String, String> entry = it.next();
                compressZip(entry.getValue(), zipStream, entry.getKey(),
                        compress);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (zipStream != null) {
                    zipStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 压缩单个文件为ZIP
     * @param file
     * @param output
     * @param encode
     * @param compress
     */
    public static void compressZip(File file, OutputStream output,
            String encode, boolean compress) throws Exception{
        FileInputStream input = null;
        try {
            input = new FileInputStream(file);
            compressZip(input,file.getName(),output,encode,compress);
        } catch (Exception e) {
            e.printStackTrace();
        }  finally {
            try {
                if (input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 压缩单个文件为ZIP
     * @param input
     * @param fileName
     * @param output
     * @param encode
     * @param compress
     */
    public static void compressZip(InputStream input, String fileName,
            OutputStream output, String encode, boolean compress) throws Exception {
        ZipOutputStream zipStream = null;
        try {
            zipStream = getZipStreamEncode(output, encode);
            zip(input, zipStream, fileName, compress);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (zipStream != null)
                    zipStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 本地图片
     */
    private static void compressZip(File file, ZipOutputStream zipStream,
            boolean compress) throws Exception{
        FileInputStream input = null;
        try {
            input = new FileInputStream(file);
            zip(input, zipStream, file.getName(), compress);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                if(input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 网络图片
     *
     * @param url
     * @param zipStream
     * @param compress
     */
    private static void compressZip(String url, ZipOutputStream zipStream,
            String fileName, boolean compress) throws Exception{
        InputStream input = null;
        try {
            input = HttpHelpers.getInputStream(url);
            zip(input, zipStream, fileName, compress);
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try {
                if(input != null)
                    input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @param input
     * @param zipStream
     * @param zipEntryName
     * @param compress
     */
    private static void zip(InputStream input, ZipOutputStream zipStream,
            String zipEntryName, boolean compress) throws Exception{
        byte[] bytes = null;
        BufferedInputStream bufferStream = null;
        try {
            if(input == null)
                throw new Exception("获取压缩的数据项失败! 数据项名为：" + zipEntryName);
            // 压缩条目不是具体独立的文件，而是压缩包文件列表中的列表项，称为条目，就像索引一样
            ZipEntry zipEntry = new ZipEntry(zipEntryName);
            // 定位到该压缩条目位置，开始写入文件到压缩包中
            zipStream.putNextEntry(zipEntry);
            if (compress) {
                bytes = CompressPictureTools.compressOfQuality(input, 0);
                zipStream.write(bytes, 0, bytes.length);
            } else {
                bytes = new byte[1024 * 5];// 读写缓冲区
                bufferStream = new BufferedInputStream(input);// 输入缓冲流
                int read = 0;
                while ((read = bufferStream.read(bytes)) != -1) {
                    zipStream.write(bytes, 0, read);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != bufferStream)
                    bufferStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}