SSM---------添加信息时，需要进行上传图片，实例可用（二）

当然，我们还需要：（这个文件可以用来上传图片，视频，文件等）

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.multipart.MultipartFile;

import net.coobird.thumbnailator.Thumbnails;


//文件上传工具
public class FileUploadTool {
	
    private static String OS = System.getProperty("os.name").toLowerCase();

	TransfMediaTool transfMediaTool = new TransfMediaTool();                                                                                
	// 文件最大500M
	private static long upload_maxsize = 500 * 1024 * 1024;
	//图片限制大小
	private static long upload_imgMaxsize = 2*1024*1024;
	// 文件允许格式
	private static String[] allowFiles = { ".rar", ".doc", ".docx", ".zip", ".pdf", ".txt", ".swf", ".xlsx", ".gif",
			".png", ".jpg", ".jpeg", ".bmp", ".xls", ".mp4", ".flv", ".ppt", ".avi", ".mpg", ".wmv", ".3gp", ".mov",
			".asf", ".asx", ".vob", ".wmv9", ".rm", ".rmvb" };
	// 允许转码的视频格式（ffmpeg）
	private static String[] allowFLV = { ".avi", ".mpg", ".wmv", ".3gp", ".mov", ".asf", ".asx", ".vob" };
	// 允许的视频转码格式(mencoder)
	private static String[] allowAVI = { ".wmv9", ".rm", ".rmvb" };
	//允许的图片类型
	private static String[] allowPIC  = {".gif",".png", ".jpg", ".jpeg", ".bmp"};
	//允许的视频类型
	private static String[] allowMedia = {".mp4", ".flv", ".ppt", ".avi", ".mpg", ".wmv", ".3gp", ".mov",
			".asf", ".asx", ".vob", ".wmv9", ".rm", ".rmvb"};
	
	

	public FileEntity createFile(MultipartFile multipartFile, HttpServletRequest request) throws Exception {
		FileEntity entity = new FileEntity();
		boolean bflag = false;
		String fileName = multipartFile.getOriginalFilename().toString();
		// 判断文件不为空
		if (multipartFile.getSize() != 0 && !multipartFile.isEmpty()) {
			bflag = true;
			// 判断文件大小
			if (multipartFile.getSize() <= upload_maxsize) {
				bflag = true;
				// 文件类型判断
				if (this.checkFileType(fileName)) {
					bflag = true;
				} else {
					bflag = false;
					throw new Exception("文件类型不允许");
				}
			} else {
				bflag = false;
				throw new Exception("文件大小超范围");
			}
		} else {
			bflag = false;
			throw new Exception("文件为空");
		}
		//如果文件类型正确
		if (bflag) {
			
			//文件上传的指定根路径    /home/salary/bank/source/upload 生产服务路径
			String logoPathDir = "";
			if(OS.contains("windows")) {
				//如果是window环境
				logoPathDir = "D:/upload";
			}else {
			    logoPathDir = "/upload";
			}
			
		  //	String logoRealPathDir = request.getSession().getServletContext().getRealPath(logoPathDir);
			// 上传到本地磁盘
			// String logoRealPathDir = "E:/upload";
			
			String name = fileName.substring(0, fileName.lastIndexOf("."));
			System.out.println("文件名称：" + name);
			// 新的文件名
			String newFileName = this.getName(name);
			// 文件扩展名
			String fileEnd = this.getFileExt(fileName);
			
			//判断是图片还是视频
			 boolean isPicType = checkPICType(fileEnd);
			 boolean isVideoType = checkVedioType(fileEnd);
			 String logoRealPathDir = null;
			 if(isPicType) {
				 logoRealPathDir = logoPathDir+"/image"; 
			 }else if(isVideoType) {
				 logoRealPathDir = logoPathDir+"/video"; 
			 }else {
				 logoRealPathDir = logoPathDir+"/other";  
			 }
			 
			 File logoSaveFile = new File(logoRealPathDir);
			 if (!logoSaveFile.exists()) {
				logoSaveFile.mkdirs();
			 }
			 
			// 绝对路径
			String fileNamedirs = logoRealPathDir + File.separator + newFileName + fileEnd;
			System.out.println("保存的绝对路径：" + fileNamedirs);
			
			File filedirs = new File(fileNamedirs);
			// 转入文件
			try {
				multipartFile.transferTo(filedirs);
			} catch (IllegalStateException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 相对路径
			entity.setType(fileEnd);
			String fileDir = logoRealPathDir +"/"+ newFileName + fileEnd;
			
			StringBuilder builder = new StringBuilder(fileDir);
			String finalFileDir = builder.substring(2);
			// size存储为String
			String size = this.getSize(filedirs);
			// 源文件保存路径
			String aviPath = filedirs.getAbsolutePath();
			// 转码Avi
			if (this.checkAVIType(fileEnd)) {
				// 设置转换为AVI格式后文件的保存路径
				String codcAviPath = logoRealPathDir + File.separator + newFileName + ".avi";
				// 获取配置的转换工具（mencoder.exe）的存放路径
				String mencoderPath = request.getSession().getServletContext().getRealPath("/tools/mencoder.exe");
				aviPath = transfMediaTool.processAVI(mencoderPath, filedirs.getAbsolutePath(), codcAviPath);
				fileEnd = this.getFileExt(codcAviPath);
			}
			if (aviPath!=null) {
				// 转码Flv
				if (this.checkMediaType(fileEnd)) {
					try {
						// 设置转换为flv格式后文件的保存路径
						String codcFilePath = logoRealPathDir + File.separator + newFileName + ".flv";
						// 获取配置的转换工具（ffmpeg.exe）的存放路径
						String ffmpegPath = request.getSession().getServletContext().getRealPath("/tools/ffmpeg.exe");
						transfMediaTool.processFLV(ffmpegPath, aviPath, codcFilePath);
						fileDir = logoPathDir + newFileName + ".flv";
						builder = new StringBuilder(fileDir);
						finalFileDir = builder.substring(1);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}else if(this.checkPICType(fileEnd)) {
					//如果是图片大于2M就进行压缩
					File compressFile = new File(aviPath);
					compressImage(filedirs, compressFile, 200, 300, "jpg");
				}
				
				entity.setSize(size);
				entity.setPath(finalFileDir);
				entity.setTitleOrig(name);
				entity.setTitleAlter(newFileName+fileEnd);				
				Timestamp timestamp = new Timestamp(System.currentTimeMillis());
				entity.setUploadTime(timestamp);
				return entity;
			} else {
				return null;
			}
		} else {
			return null;
		}

	}

	/**
	 * 文件类型判断
	 *
	 * @param fileName
	 * @return
	 */
	private boolean checkFileType(String fileName) {
		Iterator<String> type = Arrays.asList(allowFiles).iterator();
		while (type.hasNext()) {
			String ext = type.next();
			if (fileName.toLowerCase().endsWith(ext)) {
				return true;
			}
		}

		return false;
	}

	/**
	 * 视频类型判断(flv)
	 *
	 * @param fileName
	 * @return
	 */
	private boolean checkMediaType(String fileEnd) {
		Iterator<String> type = Arrays.asList(allowFLV).iterator();
		while (type.hasNext()) {
			String ext = type.next();
			if (fileEnd.equals(ext)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 视频类型判断(AVI)
	 *
	 * @param fileName
	 * @return
	 */
	private boolean checkAVIType(String fileEnd) {
		Iterator<String> type = Arrays.asList(allowAVI).iterator();
		while (type.hasNext()) {
			String ext = type.next();
			if (fileEnd.equals(ext)) {
				return true;
			}
		}
		return false;
	}
	/**
	 * 图片类型判断
	 * @param allowPIC2
	 * @return
	 */
	private boolean checkPICType(String fileEnd) {
		Iterator<String> type = Arrays.asList(allowPIC).iterator();
		while (type.hasNext()) {
			String ext = type.next();
			if (fileEnd.equals(ext)) {
				return true;
			}
		}
		return false;
	}
	/**
	 * 视频类型判断
	 * @param fileEnd
	 * @return
	 */
	private boolean checkVedioType(String fileEnd) {
		Iterator<String> type = Arrays.asList(allowMedia).iterator();
		while (type.hasNext()) {
			String ext = type.next();
			if (fileEnd.equals(ext)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 获取文件扩展名
	 *
	 * @return string
	 */
	private String getFileExt(String fileName) {
		return fileName.substring(fileName.lastIndexOf("."));
	}

	/**
	 * 依据原始文件名生成新文件名
	 * UUID：全局唯一标识符，由一个十六位的数字组成,由三部分组成：当前日期和时间、时钟序列、全局唯一的IEEE机器识别号
	 * @return string
	 */
	private String getName(String fileName) {
		Random random = new Random();
		return "" + random.nextInt(10000) + System.currentTimeMillis();
		//return UUID.randomUUID().toString() + "_" + fileName;

	}

	/**
	 * 文件大小，返回kb.mb
	 * 
	 * @return
	 */
	private String getSize(File file) {
		String size = "";
		long fileLength = file.length();
		DecimalFormat df = new DecimalFormat("#.00");
		if (fileLength < 1024) {
			size = df.format((double) fileLength) + "BT";
		} else if (fileLength < 1048576) {
			size = df.format((double) fileLength / 1024) + "KB";
		} else if (fileLength < 1073741824) {
			size = df.format((double) fileLength / 1048576) + "MB";
		} else {
			size = df.format((double) fileLength / 1073741824) + "GB";
		}

		return size;

	}
	
	/**
	 * 图片压缩
	 * @param source
	 * @param output
	 * @param width
	 * @param height
	 * @param format
	 * @throws IOException
	 */
	private void compressImage(File source,File output,int width,int height,String format) throws IOException {
		BufferedImage bufferedImage = Thumbnails.of(source).size(width, height).asBufferedImage();  
		boolean success = ImageIO.write(bufferedImage, format, output);
		if(success) {
			System.out.println("压缩成功");
		}else {
			System.out.println("压缩失败");
		}
	}

}

既然上传内容，我们还需要视频转码工具：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//视频转码工具
public class TransfMediaTool {
	/**
	 * 视频转码flv
	 * 
	 * @param ffmpegPath
	 *            转码工具的存放路径
	 * @param upFilePath
	 *            用于指定要转换格式的文件,要截图的视频源文件
	 * @param codcFilePath
	 *            格式转换后的的文件保存路径
	 * @return
	 * @throws Exception
	 */
	public void processFLV(String ffmpegPath, String upFilePath, String codcFilePath) {
		// 创建一个List集合来保存转换视频文件为flv格式的命令
		List<String> convert = new ArrayList<String>();
		convert.add(ffmpegPath); // 添加转换工具路径
		convert.add("-i"); // 添加参数＂-i＂，该参数指定要转换的文件
		convert.add(upFilePath); // 添加要转换格式的视频文件的路径
		convert.add("-ab");
		convert.add("56");
		convert.add("-ar");
		convert.add("22050");
		convert.add("-q:a");
		convert.add("8");
		convert.add("-r");
		convert.add("15");
		convert.add("-s");
		convert.add("600*500");

		/*
		 * convert.add("-qscale"); // 指定转换的质量 convert.add("6");
		 * convert.add("-ab"); // 设置音频码率 convert.add("64"); convert.add("-ac");
		 * // 设置声道数 convert.add("2"); convert.add("-ar"); // 设置声音的采样频率
		 * convert.add("22050"); convert.add("-r"); // 设置帧频 convert.add("24");
		 * convert.add("-y"); // 添加参数＂-y＂，该参数指定将覆盖已存在的文件
		 */
		convert.add(codcFilePath);

		try {
			Process videoProcess = new ProcessBuilder(convert).redirectErrorStream(true).start();
			new PrintStream(videoProcess.getInputStream()).start();
			videoProcess.waitFor();

		} catch (IOException e1) {
			e1.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 对ffmpeg无法解析的文件格式(wmv9，rm，rmvb等), 先用mencoder转换为avi(ffmpeg能解析的)格式
	 * 
	 * @param mencoderPath
	 *            转码工具的存放路径
	 * @param upFilePath
	 *            用于指定要转换格式的文件,要截图的视频源文件
	 * @param codcFilePath
	 *            格式转换后的的文件保存路径
	 * @return
	 * @throws Exception
	 */
	public String processAVI(String mencoderPath, String upFilePath, String codcAviPath) {
		boolean flag = false;
		List<String> commend = new ArrayList<String>();
		commend.add(mencoderPath);
		commend.add(upFilePath);
		commend.add("-oac");
		commend.add("mp3lame");
		commend.add("-lameopts");
		commend.add("preset=64");
		commend.add("-lavcopts");
		commend.add("acodec=mp3:abitrate=64");
		commend.add("-ovc");
		commend.add("xvid");
		commend.add("-xvidencopts");
		commend.add("bitrate=600");
		commend.add("-of");
		commend.add("avi");
		commend.add("-o");
		commend.add(codcAviPath);
		try {
			// 预处理进程
			ProcessBuilder builder = new ProcessBuilder();
			builder.command(commend);
			builder.redirectErrorStream(true);

			// 进程信息输出到控制台
			Process p = builder.start();
			BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
			String line = null;
			while ((line = br.readLine()) != null) {
				System.out.println(line);
			}
			p.waitFor();// 直到上面的命令执行完，才向下执行
			return codcAviPath;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}

	}

}

class PrintStream extends Thread {
	java.io.InputStream __is = null;

	public PrintStream(java.io.InputStream is) {
		__is = is;
	}

	public void run() {
		try {
			while (this != null) {
				int _ch = __is.read();
				if (_ch != -1)
					System.out.print((char) _ch);
				else
					break;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

我们同样也需要创建这样的一个类：

import java.sql.Timestamp;

/**
 * Created by Administrator on 2017/1/16.
 */

public class FileEntity implements java.io.Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -5101959230037200214L;

	/*****   ***/

	private long fileId;

	/*****
	 * 原文件名
	 ***/

	private String titleOrig;

	/*****
	 * 修改后文件名
	 ***/

	private String titleAlter;

	/*****
	 * 文件大小
	 ***/

	private String size;

	/*****
	 * 文件类型
	 ***/

	private String type;

	/*****
	 * 文件保存路径
	 ***/

	private String path;

	/*****
	 * 文件上传时间
	 ***/

	private Timestamp uploadTime;

	public long getFileId() {
		return fileId;
	}

	public void setFileId(long fileId) {
		this.fileId = fileId;
	}

	public String getTitleOrig() {
		return titleOrig;
	}

	public void setTitleOrig(String titleOrig) {
		this.titleOrig = titleOrig;
	}

	public String getTitleAlter() {
		return titleAlter;
	}

	public void setTitleAlter(String titleAlter) {
		this.titleAlter = titleAlter;
	}

	public String getSize() {
		return size;
	}

	public void setSize(String size) {
		this.size = size;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getPath() {
		return path;
	}

	public void setPath(String path) {
		this.path = path;
	}

	public Timestamp getUploadTime() {
		return uploadTime;
	}

	public void setUploadTime(Timestamp uploadTime) {
		this.uploadTime = uploadTime;
	}

	@Override
	public String toString() {
		return "FileEntity [fileId=" + fileId + ", titleOrig=" + titleOrig + ", titleAlter=" + titleAlter + ", size="
				+ size + ", type=" + type + ", path=" + path + ", uploadTime=" + uploadTime + "]";
	}
	
	

}