`

ant打包JPEGImageEncoder报错的问题

阅读更多

因为 jdk7 中将 JPEGImageEncoder 一除掉导致错误



 

 

 

 

解决方案:

最近做项目需要图片压缩处理,网上找的方法大都使用了 com.sun.image.codec.jpeg.* 这个包中的JPEGImageEncoder类,引入这个包后一直报错,各种google百度,尝试了各种方法,包括手动引jre中的rt.jar,以及在eclipse中把受访问限制的API提示从ERROR改为WARNING,等等,然而这些都是不好使的,因为后来我发现我的java-7-openjdk-amd64中的rt.jar里边根本就没有com.sun.image.*,貌似这个类在java7中已经被彻底remove了,至少我这个版本是没有了。然后搜了个使用ImageIO类来进行处理的替代方案,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.awt.*;
//旧的jpeg处理类
//import com.sun.image.codec.jpeg.*; 
import java.awt.image.BufferedImage;
 
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
import javax.imageio.stream.ImageOutputStream;
 
import org.w3c.dom.Element;
 
import com.sun.imageio.plugins.jpeg.*;
 
/**
 * @author zhouqz
 */
public class ImgCompressUtil {
 
    /**
     * log4j
     */
    private final static Logger logger = Logger.getLogger(ImgCompressUtil.class
            .getName());
 
    /**
     * 图片压缩测试
     
     * @param args
     */
    public static void main(String args[]) {
        // 图片url,压缩后的宽和高
        String url = "/upload/c671c57023e6eb83a1fa492babf0779e.jpg";
        int w = 700;
        int h = 500;
        //压缩后的图片路径
            String newName = MD5Util.encodeMD5(url);
            String newDir = "/var/imgcompress/";
            String filePath = newDir + newName + "_"
                    + w + "_" + h + url.substring(url.indexOf("."));
        //压缩
        ImgCompress(url,filePath,w,h);
    }
 
    /**
     * 外部调用方法
     * @param url
     * @param w
     * @param h
     */
    public static String ImgCompress(String url, String filePath, int w, int h) {
            // 压缩质量 百分比
            float JPEGcompression = 0.7f;
 
            // 本地图片存储路径
            url = "/var" + url;
            String name = url.substring(url.lastIndexOf("/") + 1);
                         
            // 截取url中最后一个“/”之后的字符串为name
            logger.info("url:===========" + url);
            logger.info("name:=========" + name);
             
            //压缩主方法
             return ImgCompress(filePath, url, name, w, h, JPEGcompression);
         
    }
     
    /**
     * 图片压缩主方法
     
     * @param newDir
     *            图片所在的文件夹路径
     * @param file
     *            图片路径
     * @param name
     *            图片名
     * @param w
     *            目标宽
     * @param h
     *            目标高
     * @param JPEGcompression
     *            压缩质量/百分比
     * @author zhouqz
     */
    public static String ImgCompress(String filePath, String url, String name,
            int w, int h, float JPEGcompression) {
        File file = new File(url);
        if (!(file.exists() && file.canRead())) {
            filePath = "/var/upload/404.jpg";
        }else{
            try {
                BufferedImage bufferedImage =  ImageIO.read(file);
                 
                //注释掉的部分是将压缩后的图像调整为方形
//              int old_w = bufferedImage.getWidth(null); // 得到源图宽
//              int old_h = bufferedImage.getHeight(null);//得到源图高
//              int new_w = 0;
//              int new_h = 0; 
//              double w2 = (old_w * 1.00) / (w * 1.00);
//              double h2 = (old_h * 1.00) / (h * 1.00);
//              // 图片跟据长宽留白,成一个正方形图。
//              BufferedImage oldpic;
//              if (old_w > old_h) {
//                  oldpic = new BufferedImage(old_w, old_w,
//                          BufferedImage.TYPE_INT_RGB);
//              } else {
//                  if (old_w < old_h) {
//                      oldpic = new BufferedImage(old_h, old_h,
//                              BufferedImage.TYPE_INT_RGB);
//                  } else {
//                      oldpic = new BufferedImage(old_w, old_h,
//                              BufferedImage.TYPE_INT_RGB);
//                  }
//              }
//              Graphics2D g = oldpic.createGraphics();
//              g.setColor(Color.white);
//              if (old_w > old_h) {
//                  g.fillRect(0, 0, old_w, old_w);
//                  g.drawImage(src, 0, (old_w - old_h) / 2, old_w, old_h,
//                          Color.white, null);
//              } else {
//                  if (old_w < old_h) {
//                      g.fillRect(0, 0, old_h, old_h);
//                      g.drawImage(src, (old_h - old_w) / 2, 0, old_w, old_h,
//                              Color.white, null);
//                  } else {
//                      // g.fillRect(0,0,old_h,old_h);
//                      g.drawImage(src.getScaledInstance(old_w, old_h,
//                              Image.SCALE_SMOOTH), 0, 0, null);
//                  }
//              }
//              g.dispose();
//              src = oldpic;
                // 图片调整为方形结束
//              if (old_w > w)
//                  new_w = (int) Math.round(old_w / w2);
//              else
//                  new_w = old_w;
//              if (old_h > h)
//                  new_h = (int) Math.round(old_h / h2);// 计算新图长宽
//              else
//                  new_h = old_h;
                 
                int new_w = w;
                int new_h = h; 
 
                BufferedImage image_to_save = new BufferedImage(new_w, new_h,
                        bufferedImage.getType());
                image_to_save.getGraphics().drawImage(
                        bufferedImage.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,
                        0null);
                FileOutputStream fos = new FileOutputStream(filePath); // 输出到文件流
 
                // 旧的使用 jpeg classes进行处理的方法
                // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(fos);
                // JPEGEncodeParam jep =
                // JPEGCodec.getDefaultJPEGEncodeParam(image_to_save);
                /* 压缩质量 */
                // jep.setQuality(per, true);
                // encoder.encode(image_to_save, jep);
 
                // 新的方法
                int dpi = 300;//分辨率
                saveAsJPEG(dpi, image_to_save, JPEGcompression, fos);
                //关闭输出流
                fos.close();
                //返回压缩后的图片地址
            catch (IOException ex) {
                logger.log(Level.SEVERE, null, ex);
                filePath = "/var/upload/404.jpg";
            }
        }
         
        return filePath;
         
    }
 
    /**
     * 以JPEG编码保存图片
     
     * @param dpi
     *            分辨率
     * @param image_to_save
     *            要处理的图像图片
     * @param JPEGcompression
     *            压缩比
     * @param fos
     *            文件输出流
     * @throws IOException
     */
    public static void saveAsJPEG(Integer dpi, BufferedImage image_to_save,
            float JPEGcompression, FileOutputStream fos) throws IOException {
 
        // useful documentation at
        // http://docs.oracle.com/javase/7/docs/api/javax/imageio/metadata/doc-files/jpeg_metadata.html
        // useful example program at
        // http://johnbokma.com/java/obtaining-image-metadata.html to output
        // JPEG data
 
        // old jpeg class
        // com.sun.image.codec.jpeg.JPEGImageEncoder jpegEncoder =
        // com.sun.image.codec.jpeg.JPEGCodec.createJPEGEncoder(fos);
        // com.sun.image.codec.jpeg.JPEGEncodeParam jpegEncodeParam =
        // jpegEncoder.getDefaultJPEGEncodeParam(image_to_save);
 
        // Image writer
        JPEGImageWriter imageWriter = (JPEGImageWriter) ImageIO
                .getImageWritersBySuffix("jpg").next();
        ImageOutputStream ios = ImageIO.createImageOutputStream(fos);
        imageWriter.setOutput(ios);
        // and metadata
        IIOMetadata imageMetaData = imageWriter.getDefaultImageMetadata(
                new ImageTypeSpecifier(image_to_save), null);
 
        // if(dpi != null && !dpi.equals("")){
        //
        // //old metadata
        // //jpegEncodeParam.setDensityUnit(com.sun.image.codec.jpeg.JPEGEncodeParam.DENSITY_UNIT_DOTS_INCH);
        // //jpegEncodeParam.setXDensity(dpi);
        // //jpegEncodeParam.setYDensity(dpi);
        //
        // //new metadata
        // Element tree = (Element)
        // imageMetaData.getAsTree("javax_imageio_jpeg_image_1.0");
        // Element jfif =
        // (Element)tree.getElementsByTagName("app0JFIF").item(0);
        // jfif.setAttribute("Xdensity", Integer.toString(dpi) );
        // jfif.setAttribute("Ydensity", Integer.toString(dpi));
        //
        // }
 
        if (JPEGcompression >= 0 && JPEGcompression <= 1f) {
 
            // old compression
            // jpegEncodeParam.setQuality(JPEGcompression,false);
 
            // new Compression
            JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter
                    .getDefaultWriteParam();
            jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
            jpegParams.setCompressionQuality(JPEGcompression);
 
        }
 
        // old write and clean
        // jpegEncoder.encode(image_to_save, jpegEncodeParam);
 
        // new Write and clean up
        imageWriter.write(imageMetaData,
                new IIOImage(image_to_save, nullnull), null);
        ios.close();
        imageWriter.dispose();
 
    }
 
}
 
转自:http://my.oschina.net/JustLoveIT/blog/474004
  • 大小: 468.5 KB
  • 大小: 399.3 KB
分享到:
评论

相关推荐

    import com.sun.image.codec.jpeg.JPEGImageEncoder;包的下载

    Access restriction: The type JPEGImageEncoder is not accessible due to restriction on required library C:\Java\jre1.6.0_07\lib\rt.jar 此时解决办法: Eclipse默认把这些受访问限制的API设成了ERROR。只要...

    Eclipse中引入com.sun.image.codec.jpeg包报错的完美解决办法

    ...幸运的是,通过以下操作可以完成解决这个问题。...通过以上两种方法都可以解决Eclipse引入com.sun.image.codec.jpeg包报错问题。如果您仍然不能解决问题,请联系我们,我们将尽力帮助您解决问题。

    获取JPEGImageEncoder和JPEGCode这两个类的方法

    `JPEGImageEncoder`和`JPEGImageDecoder`(假设描述中的`JPEGCode`是`JPEGImageDecoder`的笔误)是处理JPEG图像编码和解码的工具,但由于它们位于Oracle JDK的非公开包中,使用时需要注意兼容性和稳定性问题。...

    图片压缩 java

    com.sun.image.codec.jpeg.JPEGImageEncoder这个包不支持,需配置一下eclipse的环境

    解决eclipse导入rt包问题

    通过上述步骤,通常可以解决在Eclipse中使用`JPEGCodec` 和 `JPEGImageEncoder` 类时遇到的访问限制问题。如果问题仍然存在,可以考虑检查项目的其他设置或寻求更高级的技术支持。 #### 进一步建议 - **避免直接...

    PNGEncoder,JPEGEncoder图像编码

    通过PNGEncoder、JPEGEncoder对bitmapdata进行encode转换为对应图像格式的bytearray,这时会根据对应图像格式的压缩算法转换为编码图像的bytearray,如JPEGEncoder 类使用联合图像专家组 (JPEG) 压缩将原始的位图...

    java图片操作两个接口一个类的api

    在Java编程语言中,处理图像数据,特别是JPEG格式的图像,通常涉及到三个核心组件:`JPEGImageEncoder`接口、`JPEGImageDecoder`接口和`JPEGCodec`类。这些组件是Java Advanced Imaging (JAI)库的一部分,允许开发者...

    java图片编码、解码的接口中文api

    在实际使用中,你需要创建一个`JPEGEncodeParam`对象来设置这些参数,然后通过`JPEGImageEncoder`的`encode`方法进行编码。 2. **JPEGCodec类**: - `JPEGCodec`是Java Image I/O库中的核心类,它提供了一系列静态...

    java 使用ImageIO.writer从BufferedImage生成jpeg图像遇到问题总结及解决

    在Java中,将BufferedImage对象转换为JPEG图像时,常遇到的问题及解决方法如下所述: 首先,早期的Java实现中,一个简便的方法是通过sun的JPEGImageEncoder类来实现BufferedImage到JPEG的转换。该类非标准Java API...

    java调用条码打印机.txt

    JPEGImageEncoder jpegImageEncoder = JPEGCodec.createJPEGEncoder(output); JPEGEncodeParam jpegEncodeParam = jpegImageEncoder .getDefaultJPEGEncodeParam(bufferedImage); jpegEncodeParam.setQuality...

    多张jpg图合成gif动画.doc

    6、JPEGImageEncoder类:在splitGif方法中,我们使用了JPEGImageEncoder类来编码jpg图像。JPEGImageEncoder类是Java中用来编码jpg图像的基本类之一。它提供了多种方法来编码jpg图像,例如设置图像质量、设置图像大小...

    JSP画图程序简介

    在 JDK 1.3 中,程序使用 JPEGImageEncoder 对象将 BufferedImage 编码成 JPEG 格式输出到输出流。在 JDK 1.4 及更高版本中,程序使用 ImageIO 对象将图像输出到输出流。 此外,程序还提供了从数据库中读取图片并...

    eclispe错误

    在处理图片相关的功能时,如果你的项目确实需要使用 `JPEGCodec` 和 `JPEGImageEncoder` 类,你可能需要考虑寻找替代的开源库,如 Apache Commons Imaging(原名 Apache Sanselan)或 Java Advanced Imaging (JAI),...

    基于JAVA的JPEG图像生成器的实现

    该JPEG图像生成器由1个java源文件...将图像对象保存成JPEG文件由JPEG编码器(JPEGImageEncoder)负责。获取计算机图像则由Robot对象负责。屏幕图像同时绘制到画布上和图像对象中,并由编码器将图像对象保存成JPEG文件。

    Convert bmp to jpg

    本篇文章将详细探讨如何使用Java中的JPEGImageEncoder类来实现BMP(位图)到JPG(联合图像专家组)格式的转换。 BMP是一种无损的图像文件格式,它通常会占用较大的存储空间,而JPG则是一种有损的压缩格式,适用于...

    利用java实现在图片上添加水印.doc

    为了解决这个问题,可以使用Apache Commons Imaging (formerly known as Apache Sanselan) 或者 Java Advanced Imaging (JAI) 这样的第三方库来处理JPEG编码。 此外,为了使代码更具通用性和灵活性,可以考虑添加更...

    文件生成图片

    JPEGImageEncoder enc = JPEGCodec.createJPEGEncoder(boutstream); JPEGEncodeParam params = JPEGCodec.getDefaultJPEGEncodeParam(bufImg); params.setQuality(100, true); enc.encode...

    java压缩上传图片

    - **解决方案**:通过图片压缩技术,可以有效地控制上传图片的大小,避免因图片过大导致的硬盘空间不足问题。 ### 7. 知识点七:自定义图片尺寸 - **配置项**: - `outputWidth`: 输出图片的宽度。 - `output...

    使用Servlet输出流技术来为JPEG图片制作图形文字

    在这个特定的例子中,`DrawServlet` 是一个实现图形文字生成的Servlet,它利用了`JPEGImageDecoder`和`JPEGImageEncoder`来处理JPEG图片,并在图片上添加文本,然后将结果发送回浏览器。下面我们将详细探讨这个过程...

Global site tag (gtag.js) - Google Analytics