Java 压缩图片并打成ZIP

引用

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

Java代码  收藏代码

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


Java代码  收藏代码

    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简单

Java代码  收藏代码

     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

Java代码  收藏代码

    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(); 
                } 
            } 
        } 
    }