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

需求简单介绍：

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

设计方案

　　

　　

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秒，查了很多试了很多也没找到合适方法，暂且就用这个吧。如果有好的方法还望大家多多指教。

  1. package com.minxinloan.black.web.utils;
  3. import java.awt.Graphics;
  4. import java.awt.Image;  
  5. import java.awt.image.BufferedImage;  
  6. import java.io.File;  
  7. import java.io.FileOutputStream;  
  8. import java.io.IOException;
  9.   
  10. import javax.imageio.ImageIO;  
  12. import org.apache.log4j.Logger;
  13. //  
  14. import com.sun.image.codec.jpeg.JPEGCodec;  
  15. import com.sun.image.codec.jpeg.JPEGImageEncoder;  
  16. //
  17. //import com.sun.media.jai.codecimpl.JPEGCodec;
  18. //import com.sun.media.jai.codecimpl.JPEGImageEncoder;
  19.   
  20.  
  21.  
  22.  
  23. public class ImagesUtils {  
  24.   
  25.     private final static Logger log = Logger.getLogger(ImagesUtils.class);    
  26.     //图片允许的最大大小
  27.     public static final int IMAGEMAXSIZE = 1024*1024;
  28.     // 图片宽和高的最大尺寸  
  29.     public static final int IMAGEMAXBIG = 2000;  
  30.     // 图片宽和高的最小尺寸  
  31.     public static final int IMAGEMINBIG = 10;  
  32.     // 按原图大小生成新图  
  33.     public static final int CREATENEWIMAGETYPE_0 = 0;  
  34.     // 按指定的大小生成新图  
  35.     public static final int CREATENEWIMAGETYPE_1 = 1;  
  36.     // 按原图宽高比例生成新图-按指定的宽度  
  37.     public static final int CREATENEWIMAGETYPE_2 = 2;  
  38.     // 按原图宽高比例生成新图-按指定的高度  
  39.     public static final int CREATENEWIMAGETYPE_3 = 3;  
  40.     // 按原图宽高比例生成新图-按指定的宽和高中较大的尺寸  
  41.     public static final int CREATENEWIMAGETYPE_4 = 4;  
  42.     // 按原图宽高比例生成新图-按指定的宽和高中较小的尺寸  
  43.     public static final int CREATENEWIMAGETYPE_5 = 5;  
  44.     // 按原图宽高比例生成新图-按原图大小的90%进行修改 
  45.     public static final int CREATENEWIMAGETYPE_6 = 6;
  46.   
  47.     /** 
  48.      *  
  49.      * @param _file 
  50.      *            原图片 
  51.      * @param createType 
  52.      *            处理类型 
  53.      * @param newW 
  54.      *            新宽度 
  55.      * @param newH 
  56.      *            新高度 
  57.      * @return 
  58.      * @throws Exception 
  59.      */  
  60.     public static String createNewImage(File _file, int createType, int newW,  
  61.             int newH) throws Exception {  
  62.         if (_file == null)  
  63.             return null;  
  64.         String fileName = _file.getPath();  
  65.         if (fileName == null || "".equals(fileName)  
  66.                 || fileName.lastIndexOf(".") == -1)  
  67.             return null;  
  68.         /* 
  69.          * else newFileName = "_" + newFileName; 
  70.          */  
  71.   
  72.         String outFileName = fileName.substring(0, fileName.lastIndexOf(".")) 
  73.                 + fileName.substring(fileName.lastIndexOf("."), fileName  
  74.                         .length());  
  75.         String fileExtName = fileName.substring(  
  76.                 (fileName.lastIndexOf(".") + 1), fileName.length());  
  77.         if (newW < IMAGEMINBIG)  
  78.             newW = IMAGEMINBIG;  
  79.         else if (newW > IMAGEMAXBIG)  
  80.             newW = IMAGEMAXBIG;  
  81.   
  82.         if (newH < IMAGEMINBIG)  
  83.             newH = IMAGEMINBIG;  
  84.         else if (newH > IMAGEMAXBIG)  
  85.             newH = IMAGEMAXBIG;  
  86.   
  87.         // 得到原图信息  
  88.         if (!_file.exists() || !_file.isAbsolute() || !_file.isFile()  
  89.                 || !checkImageFile(fileExtName))  
  90.             return null;  
  91.         Image src = ImageIO.read(_file);  
  92.         int w = src.getWidth(null);  
  93.         int h = src.getHeight(null);  
  94.   
  95.         // 确定目标图片的大小  
  96.         int nw = w;  
  97.         int nh = h;  
  98.         if (createType == CREATENEWIMAGETYPE_0)  
  99.             ;  
  100.         else if (createType == CREATENEWIMAGETYPE_1) {  
  101.             nw = newW;  
  102.             nh = newH;  
  103.         } else if (createType == CREATENEWIMAGETYPE_2) {  
  104.             nw = newW;  
  105.             nh = (int) ((double) h / (double) w * nw);  
  106.         } else if (createType == CREATENEWIMAGETYPE_3) {  
  107.             nh = newH;  
  108.             nw = (int) ((double) w / (double) h * nh);  
  109.         } else if (createType == CREATENEWIMAGETYPE_4) {  
  110.             if ((double) w / (double) h >= (double) newW / (double) newH) {  
  111.                 nh = newH;  
  112.                 nw = (int) ((double) w / (double) h * nh);  
  113.             } else {  
  114.                 nw = newW;  
  115.                 nh = (int) ((double) h / (double) w * nw);  
  116.             }  
  117.         } else if (createType == CREATENEWIMAGETYPE_5) {  
  118.             if ((double) w / (double) h <= (double) newW / (double) newH) {  
  119.                 nh = newH;  
  120.                 nw = (int) ((double) w / (double) h * nh);  
  121.             } else {  
  122.                 nw = newW;  
  123.                 nh = (int) ((double) h / (double) w * nw);  
  124.             }  
  125.         } else if(createType == CREATENEWIMAGETYPE_6){
  126. //            nw = (int)(w*0.5);  
  127. //            nh = (int)(h*0.5); 
  128.             double proportion = (double)1700/(double)w;
  129.             nw = (int)((double)w*proportion);
  130.             nh = (int)((double)h*proportion);
  131.         } 
  132.   
  133.         // 构造目标图片  
  134.         BufferedImage tag = new BufferedImage(nw, nh,  
  135.                 BufferedImage.TYPE_INT_RGB);  
  136.   
  137.         // 得到目标图片输出流  
  138.         FileOutputStream out = new FileOutputStream(outFileName);  
  139.   
  140.         // 根据需求画出目标图片 方式1  
  141.         tag.getGraphics().drawImage(src, 0, 0, nw, nh, null);  
  142.   
  143.         // 将画好的目标图输出到输出流 方式1  
  144.         JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);  
  145.         encoder.encode(tag);  
  146.         out.close();  
  147.         return outFileName;  
  148.     }  
  149.   
  150.     public static boolean checkImageFile(String extName) {  
  151.   
  152.         if ("jpg".equalsIgnoreCase(extName))  
  153.             return true;  
  154.         if ("gif".equalsIgnoreCase(extName))  
  155.             return true;  
  156.         if ("bmp".equalsIgnoreCase(extName))  
  157.             return true;  
  158.         if ("jpeg".equalsIgnoreCase(extName))  
  159.             return true;  
  160.         if ("png".equalsIgnoreCase(extName))  
  161.             return true;  
  162.         return false;  
  163.     }  
  164.     public static String checkImageFile2(String extName) {  
  165.           
  166.         if ("jpg".equalsIgnoreCase(extName))  
  167.             return "jpg";  
  168.         if ("gif".equalsIgnoreCase(extName))  
  169.             return "gif";  
  170.         if ("bmp".equalsIgnoreCase(extName))  
  171.             return "bmp";  
  172.         if ("jpeg".equalsIgnoreCase(extName))  
  173.             return "jpeg";  
  174.         if ("png".equalsIgnoreCase(extName))  
  175.             return "jpeg";  
  176.         return null;  
  177.     }  
  178.    
  179.     
  180.     //递归修改图片大小
  181.     public static void changeImgSize(String filePath,int createType)
  182.     {
  183.         try {
  184.             File tempFile = new File(filePath);
  185.             if(tempFile.length()>IMAGEMAXSIZE){
  186.                 System.out.println("sss");
  187.                 changeImgSize(createNewImage(tempFile, createType, 0, 0),createType);
  188.             }
  189.         } catch (Exception e) {
  190.             log.error("the changeImgSize is failed . the message is "+e.getMessage());
  191.         }
  192.     }
  193.     /**
  194.      * 缩放图像（按比例缩放）
  195.      * @param srcImageFile 源图像文件地址
  196.      * @param result 缩放后的图像地址
  197.      * @param scale 缩放比例
  198.      * @param flag 缩放选择:true 放大; false 缩小;
  199.      */
  200.     public final static void scale(String srcImageFile,String type, String result) {
  201.         try {
  202.             
  203.             File tempFile = new File(srcImageFile);
  204.             if(tempFile.length()>IMAGEMAXSIZE){
  205.                 System.out.println("sss");
  206.                 BufferedImage src = ImageIO.read(tempFile); // 读入文件
  207.                 int width = src.getWidth(); // 得到源图宽
  208.                 int height = src.getHeight(); // 得到源图长
  209.                 
  210.                 double sc = (double)1700/(double)width;
  211.                 
  212.              
  213.                 width = (int)((double)width * sc);
  214.                 height = (int)((double)height * sc);
  215.               
  216.                 Image image = src.getScaledInstance(width, height,
  217.                         Image.SCALE_DEFAULT);
  218.                 BufferedImage tag = new BufferedImage(width, height,
  219.                         BufferedImage.TYPE_INT_RGB);
  220.                 Graphics g = tag.getGraphics();
  221.                 g.drawImage(image, 0, 0, null); // 绘制缩小后的图
  222.                 g.dispose();
  223.                 ImageIO.write(tag, type, new File(result));// 输出到文件流
  224.             }
  225.         } catch (IOException e) {
  226.             e.printStackTrace();
  227.         }
  228.     }
  229.     
  230.     
  231.     public static void changeImgSize(File file)
  232.      {
  233.          try {
  234.                 // 判断文件是否是文件，如果是文件，获取路径，并计数
  235.                 if (file.isFile()) {
  236.                     String fileExtName = file.getName().substring(  
  237.                             (file.getName().lastIndexOf(".") + 1), file.getName().length());  
  238.                     
  239.                     String temp = ImagesUtils.checkImageFile2(fileExtName);
  240.                     if(temp!=null)
  241.                         //scale(file.getAbsolutePath(),temp,file.getAbsolutePath());
  242.                         ImagesUtils.changeImgSize(file.getAbsolutePath(), ImagesUtils.CREATENEWIMAGETYPE_6);
  243.                 } else {
  244.                     // 如果是文件夹，声明一个数组放文件夹和他的子文件
  245.                     File[] f = file.listFiles();
  246.                     // 遍历文件件下的文件，并获取路径
  247.                     for (File file2 : f) {
  248.                         changeImgSize(file2);
  249.                     }
  250.                 }
  251.             } catch (RuntimeException e) {
  252.                 e.printStackTrace();
  253.             }
  254.      }
  255.   
  256.     public static void main(String[] args) {
  257.         
  259.         
  260.         
  261. //
  262. //        long start=System.currentTimeMillis();
  263. //        String filePath = "C:\\Users\\zhangmi\\Desktop\\资料";
  264. //        changeImgSize(new File(filePath));
  265. //
  266. //        long end=System.currentTimeMillis();
  267. //        //在最好的一行加上:
  268. //        System.out.println("执行耗时 : "+(end-start)/1000f+" 秒 ");
  269.         
  270.     }
  271. }

 

做已铭记

 

 

版权声明：本文为puqiuxiaomao原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/puqiuxiaomao/p/java.html