纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术 → Java 压缩图片并打包成ZIP文件的示例

Java 压缩图片并打包成ZIP文件的示例

烟-波-天-客   2020-12-02 我要评论

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

相关文章

猜您喜欢

网友评论

Copyright 2020 www.cantonsoft.net 【广东软件网】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式