package common;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;
public class ImageCompressionTask implements Runnable{
private InputStream is;
private String fileName;
private int width;
private int height;
/**
* 初始化参数
* @param is 图片输入流
* @param file 图片
* @param fileName 图片名称
* @param width 高
* @param height 宽
*/
public ImageCompressionTask(InputStream is,String fileName,int width,int height) {
this.is=is;
this.fileName=fileName;
this.width=width;
this.height=height;
}
public void run() {
// TODO Auto-generated method stub
try{
this.compressPic();
}catch(Exception e){
System.out.println("文件压缩失败"+e);
}
}
private String compressPic() throws Exception{
String path = "E:\\xie\\";//新图片存放路径
String urlPath = path + fileName;
BufferedImage buffImage;
FileOutputStream output=null;
BufferedImage compressPic=null;
try {
String imagetype = "";
if(fileName.lastIndexOf(".") != -1){
imagetype = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
}
imagetype = imagetype.toLowerCase(); //文件后缀名
output=new FileOutputStream(urlPath);
buffImage=ImageIO.read(is);
//图片缩放
compressPic=compressPicMin(buffImage,width,height);
//输出图片
ImageIO.write(compressPic, imagetype, output);
} finally {
if(output!=null){
try{
output.close();
}catch(IOException e){
e.getStackTrace();
}
}
if(is!=null){
is.close();
}
}
return fileName;
}
/**
* 图片等比缩放
*@param image 图片输入缓存流
*@param outputWidth 图片压缩到的宽
*@param outputHeight 图片压缩到的高
*@return BufferedImage
* */
private BufferedImage compressPicMin(BufferedImage image,
int outputWidth, int outputHeight) {
// TODO Auto-generated method stub
if(image==null){
return null;
}
//如果图片本身的宽和高均小于要压缩到的宽和高，则不压缩直接返回
if(outputWidth>image.getWidth(null)&&outputHeight>image.getHeight(null)){
return image;
}
int newWidth;
int newHeight;
//宽和高等比缩放的率
double rate1=(double)image.getWidth(null)/(double)outputWidth;
double rate2=(double)image.getHeight(null)/(double)outputHeight;
//控制缩放大小
double rate=rate1<rate2 ? rate1:rate2;
newWidth=(int) (image.getWidth(null)/rate);
newHeight=(int) (image.getHeight(null)/rate);
BufferedImage newImage=new BufferedImage(newWidth, newHeight,BufferedImage.TYPE_INT_RGB);
newImage.createGraphics().drawImage(image.getScaledInstance(newWidth, outputHeight, Image.SCALE_SMOOTH), 0, 0, null);
return newImage;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
}创建ImageTest写一个main（）
package test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import common.ImageCompressionTask;
public class ImageTest {
public static void main(String[] args){
String imgName = System.currentTimeMillis() + "_" + ((int) (Math.random() * 900) + 100) + "." + "jpg";
File f=new File("E:\\xie\\xxx.jpg");
try {
InputStream input = new FileInputStream(f);
ImageCompressionTask r=new ImageCompressionTask(input, imgName, 520, 320);
/*
* 方法一：
*
Thread thread1 = new Thread(r);
thread1.start(); // 启动线程
*/
/*
* 方法二：使用ThreadPoolExecutor创建线程池，并不提倡我们直接使用ThreadPoolExecutor
*
*/
/* ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
10, //线程池最大能容忍的线程数
200, //线程存活时间
TimeUnit.MILLISECONDS, //参数keepAliveTime的时间单位
new ArrayBlockingQueue<Runnable>(5) //任务缓存队列，用来存放等待执行的任务
);
executor.execute(r);*/
/*
* 方法三：并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池
* 以下是三个静态方法
* Executors.newCachedThreadPool(); //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
* Executors.newSingleThreadExecutor(); //创建容量为1的缓冲池
* Executors.newFixedThreadPool(int); //创建固定容量大小的缓冲池
*/
newCachedThreadPool().execute(r);
//newSingleThreadExecutor().execute(r);
//newFixedThreadPool(10).execute(r);
System.out.println("图片上传成功");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*静态方法的具体实现
* Executors.newCachedThreadPool()
* 创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
/*静态方法的具体实现
* Executors.newSingleThreadExecutor()
* 创建容量为1的缓冲池
*/
public static ExecutorService newSingleThreadExecutor() {
return new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
/*静态方法的具体实现
* Executors.newFixedThreadPool(int)
* 创建固定容量大小的缓冲池
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
}
