文件上传类，通用

package com.beijian.action;

import com.beijian.common.util.FileUtil;
import com.beijian.common.util.ImageMarkUtil;
import com.beijian.common.util.ImageZipUtil;
import com.beijian.common.util.PropertiesUtil;
import com.beijian.function.SysconfigFuc;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.springframework.stereotype.Controller;

@Controller
public class UpFileAction extends BaseAction {
	private static final String cfg_imgtype = "cfg_imgtype";
	private static final String cfg_attachtype = "cfg_attachtype";
	private static final String cfg_mediatype = "cfg_mediatype";
	private static final String cfg_ddimg_width = "cfg_ddimg_width";
	private static final String cfg_ctrl_img = "cfg_ctrl_img";
	private static final String cfg_imagemark = "cfg_imagemark";
	private static final String cfg_imagemarktype = "cfg_imagemarktype";
	private static final String cfg_imagemarkdegree = "cfg_imagemarkdegree";
	private static final String cfg_imagemarkalpha = "cfg_imagemarkalpha";
	private static final String cfg_imagemarkwidth = "cfg_imagemarkwidth";
	private static final String cfg_imagemarkheight = "cfg_imagemarkheight";
	private static final String cfg_imagemaricon = "cfg_imagemaricon";
	private static final String cfg_imagemarktext = "cfg_imagemarktext";
	private static final String cfg_imageforntsize = "cfg_imageforntsize";

	private static final String cfg_imagemarkbold = "cfg_imagemarkbold";

	private static final String cfg_smallimage = "cfg_smallimage";
	private static final String cfg_middleimage = "cfg_middleimage";
	private static final String cfg_bigimage = "cfg_bigimage";
	private static final String _$26 = "text/html; charset=UTF-8";
	private String proUtil = PropertiesUtil.getRootpath();
	public int IMG_WIDTH = 100;
	public File uploadifyfile;
	private final String uploads = "uploads";
	private static final String images = "images";
	public String IMAGE_TYPE = "";
	private static final int three = 3;
	private static final String video = "video";
	public String FLASH_TYPE = "";
	private static final int fifty = 50;
	private static final String file = "file";
	public String FILE_TYPE = "";
	private static final int ten = 10;
	private String temp_file_path = "";
	public String temp_file_type = "";
	public int temp_file_size = 0;
	public String uploadifyfileFileName;
	public String isImgControl;
	public String isYin;
	public String isImgControl_isYin;

	
	public String executeUpFlash() throws Exception {
		this.FLASH_TYPE = SysconfigFuc.getSysValue(cfg_mediatype);
		if (this.temp_file_path.equals("")) {
			setTemp_file_path(video);
			setTemp_file_size(fifty);
			setTemp_file_type(this.FLASH_TYPE);
		}
		String imageSavePath = getImageSavePath();
		String uploadFileName = new FileUtil().getFileExt(this.uploadifyfileFileName);
		String fileNameByDate = createFileNameByDate(uploadFileName);
		String file_type = "";
		
		if (this.temp_file_type.indexOf(uploadFileName) == -1) {
			file_type = this.temp_file_type + " is allowed";
		} else {
			InputStream in = new FileInputStream(this.uploadifyfile);
			OutputStream out = new FileOutputStream(new File(imageSavePath
					+ File.separator + fileNameByDate));
			try {
				byte[] arrayOfByte = new byte[1048576];
				while (in.read(arrayOfByte) > 0)
					out.write(arrayOfByte);
			} catch (Exception strException) {
				strException.printStackTrace();
				file_type = "upload fail";
			} finally {
				if (in != null)
					in.close();
				if (out != null)
					out.close();
			}
		}
		String ss = "/uploads/" + this.temp_file_path + "/"
				+ getYearMonthDay() + "/" + fileNameByDate;
		if (!file_type.equals("")) {
			ss = "";
		}
		
		
		HttpServletResponse response = getResponse();
		PrintWriter printWriter = response
				.getWriter();
		response.getWriter().print(ss);
		return "none";
	}

	public String executeUpFile() throws Exception {
		this.FILE_TYPE = SysconfigFuc.getSysValue(cfg_imgtype).toString();
		if (this.temp_file_path.equals("")) {
			setTemp_file_path(file);
			setTemp_file_size(ten);
			setTemp_file_type(this.FILE_TYPE);
		}
		String imageSavePath = getImageSavePath();
		String uploadFileName = new FileUtil().getFileExt(this.uploadifyfileFileName);
		String fileNameByDate = createFileNameByDate(uploadFileName);
		String file_type = "";
		if (this.temp_file_type.indexOf(uploadFileName) == -1) {
			file_type = this.temp_file_type + " is allowed";
		} else {
			InputStream input = new FileInputStream(this.uploadifyfile);
			OutputStream out = new FileOutputStream(new File(imageSavePath
					+ File.separator + fileNameByDate));
			try {
				byte[] arrayOfByte = new byte[1048576];
				while (input.read(arrayOfByte) > 0)
					out.write(arrayOfByte);
			} catch (Exception strException) {
				strException.printStackTrace();
				file_type = "upload fail";
			} finally {
				if (input != null)
					input.close();
				if (out != null)
					out.close();
			}
		}
		String path = "/uploads/" + this.temp_file_path + "/"
				+ getYearMonthDay() + "/" + fileNameByDate;
		if (!file_type.equals("")) {
			path = "";
		}
		HttpServletResponse response = getResponse();
		PrintWriter printWriter = response.getWriter();
		response.getWriter().print(path);
		return "none";
	}

	public String executeUpGoodsimages() throws Exception {
		this.IMG_WIDTH = Integer.parseInt(SysconfigFuc
				.getSysValue(cfg_ddimg_width));
		this.IMAGE_TYPE = SysconfigFuc.getSysValue(cfg_imgtype).toString();
		if (this.temp_file_path.equals("")) {
			setTemp_file_path(images);
			setTemp_file_size(three);
			setTemp_file_type(this.IMAGE_TYPE);
		}
		String imageSavePath = getImageSavePath();
		String uploadFileName = new FileUtil().getFileExt(this.uploadifyfileFileName);
		String fileNameByDate = createFileNameByDate(uploadFileName);
		String file_type = fileNameByDate.replace("." + uploadFileName, "");
		String str5 = "";
		
		if (this.temp_file_type.indexOf(uploadFileName) == -1) {
			str5 = this.temp_file_type + " is allowed";
		} else {
			InputStream input = new FileInputStream(this.uploadifyfile);
			OutputStream out = new FileOutputStream(new File(imageSavePath
					+ File.separator + fileNameByDate));
			try {
				byte[] arrayOfByte = new byte[1048576];
				while (input.read(arrayOfByte) > 0) {
					out.write(arrayOfByte);
					out.flush();
				}
			} catch (Exception strException) {
				strException.printStackTrace();
			} finally {
				if (input != null)
					input.close();
				if (out != null)
					out.close();
			}
		}
		
		String path = "uploads/" + this.temp_file_path + "/" + getYearMonthDay();
		
		String pUtil = this.proUtil + path + "/" + fileNameByDate;
		String str6 = "";
		int i = pUtil.lastIndexOf(".");
		if (i > -1) {
			str6 = pUtil.substring(0, i);
		}
		String str7 = str6 + "_small." + uploadFileName;
		FileUtil fileUtil = new FileUtil();
		fileUtil.copyFile(pUtil, str7);
		String str8 = str6 + '.' + uploadFileName;
		String str9 = str6 + "_big." + uploadFileName;
		fileUtil.copyFile(pUtil, str9);
		String str10 = "/" + path + "/" + file_type + "." + uploadFileName;
		
		HttpServletResponse response = getResponse();
		response.setCharacterEncoding("UTF-8");
		PrintWriter printWriter = response.getWriter();
		printWriter.write(str10);
		ImageZipUtil strImageZipUtil = new ImageZipUtil();
		String str11 = SysconfigFuc.getSysValue(cfg_smallimage).toString();
		int k;
		
		if (str11.indexOf("，") > -1) {
			String[] array = str11.split("，");
			if (array.length > 1) {
				int j = Integer.parseInt(array[0].toString());
				k = Integer.parseInt(array[1].toString());
				strImageZipUtil.imageZipProce(str7, j, k, 1.0F);
			}
		}
		String value1 = SysconfigFuc.getSysValue(cfg_middleimage)
				.toString();
		int m = 0;
		if (value1.indexOf("，") > -1) {
			String[] array1 = value1.split("，");
			if (array1.length > 1) {
				k = Integer.parseInt(array1[0].toString());
				m = Integer.parseInt(array1[1].toString());
				strImageZipUtil.imageZipProce(str8, k, m, 1.0F);
			}
		}
		String value = SysconfigFuc.getSysValue(cfg_middleimage)
				.toString();
		if (value.indexOf("，") > -1) {
			String[] array = value.split("，");
			if (array.length > 1) {
				m = Integer.parseInt(array[0].toString());
				int n = Integer.parseInt(array[1].toString());
				strImageZipUtil.imageZipProce(str9, m, n, 1.0F);
			}
		}
		return "none";
	}

	public String executeUpimages() throws Exception {
		this.IMG_WIDTH = Integer.parseInt(SysconfigFuc
				.getSysValue(cfg_ddimg_width));
		this.IMAGE_TYPE = SysconfigFuc.getSysValue(cfg_imgtype).toString();
		if (this.temp_file_path.equals("")) {
			setTemp_file_path(images);
			setTemp_file_size(three);
			setTemp_file_type(this.IMAGE_TYPE);
		}
		String imageSavePath = getImageSavePath();
		String uploadFileName = new FileUtil().getFileExt(this.uploadifyfileFileName);
		String fileNameByDate = createFileNameByDate(uploadFileName);
		String file_type = "";
		if (this.temp_file_type.indexOf(uploadFileName) == -1) {
			file_type = this.temp_file_type + " is allowed";
		} else {
			InputStream input = new FileInputStream(this.uploadifyfile);
			OutputStream out = new FileOutputStream(new File(imageSavePath
					+ File.separator + fileNameByDate));
			try {
				byte[] arrayOfByte = new byte[1048576];
				while (input.read(arrayOfByte) > 0)
					out.write(arrayOfByte);
			} catch (Exception strException) {
				strException.printStackTrace();
				file_type = "upload fail";
			} finally {
				if (input != null)
					input.close();
				if (out != null)
					out.close();
			}
		}
		String path = "/uploads/" + this.temp_file_path + "/"
				+ getYearMonthDay() + "/" + fileNameByDate;
		
		
		if (!file_type.equals("")) {
			path = "";
		}

		HttpServletResponse response = getResponse();
		PrintWriter printWriter =response
				.getWriter();
		response.getWriter().print(path);
		
		String str5 = "";
		
		if ((this.isImgControl != null) && (!"".equals(this.isImgControl))) {
			str5 = SysconfigFuc.getSysValue(cfg_ctrl_img);
			if ((str5 != null) && (!str5.equals("")))
				zipimagesproces(imageSavePath + File.separator + fileNameByDate, str5);
		} else if ((this.isYin != null) && (!"".equals(this.isYin))) {
			str5 = SysconfigFuc.getSysValue(cfg_ddimg_width);
			if ((str5 != null) && (!str5.equals("")))
				zipimagesproces(imageSavePath + File.separator + fileNameByDate, str5);
			imageMarkProcess(imageSavePath + File.separator + fileNameByDate);
		} else if ((this.isImgControl_isYin != null)
				&& (!"".equals(this.isImgControl_isYin))) {
			str5 = SysconfigFuc.getSysValue(cfg_ctrl_img);
			if ((str5 != null) && (!str5.equals("")))
				zipimagesproces(imageSavePath + File.separator + fileNameByDate, str5);
			imageMarkProcess(imageSavePath + File.separator + fileNameByDate);
		} else {
			str5 = SysconfigFuc.getSysValue(cfg_ddimg_width);
			if ((str5 != null) && (!str5.equals("")))
				zipimagesproces(imageSavePath + File.separator + fileNameByDate, str5);
		}
		return "none";
	}

	public void zipimagesproces(String paramString1, String paramString2) {
		ImageZipUtil imageZip = new ImageZipUtil();
		Integer strInteger = Integer.valueOf(0);
		if ((paramString2 != null) && (!paramString2.equals(""))
				&& (!paramString2.equals("0"))) {
			strInteger = Integer.valueOf(Integer.parseInt(paramString2));
			imageZip.imageZipProce(paramString1, strInteger
					.intValue(), strInteger.intValue(), 1.0F);
		}
	}

	public void imageMarkProcess(String paramString) {
		ImageMarkUtil imageMarkUtil = new ImageMarkUtil();
		String str1 = "";
		String str2 = "";
		Integer integer1 = Integer.valueOf(0);
		Integer integer2 = Integer.valueOf(0);
		Integer integer3 = Integer.valueOf(0);
		Integer integer4 = Integer.valueOf(0);
		
		if (!SysconfigFuc.getSysValue(cfg_imagemark).equals("1")) {
			str1 = SysconfigFuc.getSysValue(cfg_imagemaricon);
			integer1 = Integer.valueOf(Integer.parseInt(SysconfigFuc
					.getSysValue(cfg_imagemarkdegree)));
			integer2 = Integer.valueOf(Integer.parseInt(SysconfigFuc
					.getSysValue(cfg_imagemarkwidth)));
			integer3 = Integer.valueOf(Integer.parseInt(SysconfigFuc
					.getSysValue(cfg_imagemarkheight)));
			Float strFloat = Float.valueOf(Float.parseFloat(SysconfigFuc
					.getSysValue(cfg_imagemarkalpha)));
			integer4 = Integer.valueOf(Integer.parseInt(SysconfigFuc
					.getSysValue(cfg_imageforntsize)));
			str2 = SysconfigFuc.getSysValue(cfg_imagemarktext);
			if (SysconfigFuc.getSysValue(cfg_imagemarktype).equals("0"))
				imageMarkUtil.markImageByIcon(str1, paramString,
						paramString, integer1, strFloat.floatValue(),
						integer2, integer3);
			else if (SysconfigFuc.getSysValue(cfg_imagemarktype).equals("1"))
				imageMarkUtil.markByText(str2, paramString, paramString,
						integer1, strFloat.floatValue(), integer2,
						integer3, integer4);
		}
	}

	public String execute() throws ServletException, IOException {
		if (this.temp_file_path.equals("")) {
			setTemp_file_path(images);
			setTemp_file_size(three);
			setTemp_file_type(this.IMAGE_TYPE);
		}
		HttpServletRequest request = getRequest();
		HttpServletResponse response = getResponse();
		String imageSavePath = getImageSavePath();
		System.out.print("路径为：======:" + imageSavePath);
		File file1 = new File(imageSavePath);
		if (!file1.exists())
			file1.mkdirs();
		DiskFileItemFactory disfDiskFileItemFactory = new DiskFileItemFactory();
		ServletFileUpload servletFileUpload = new ServletFileUpload(
				disfDiskFileItemFactory);
		servletFileUpload.setHeaderEncoding("UTF-8");
		List list = null;
		try {
			list = servletFileUpload.parseRequest(request);
			System.out.print("文件个数为：======:" + list.size());
		} catch (FileUploadException fileUploadException) {
			return null;
		}
		Iterator it = list.iterator();
		String str2 = "";
		String str3 = "";
		while (it.hasNext()) {
			FileItem fileItem = (FileItem) it.next();
			if (!fileItem.isFormField()) {
				str2 = fileItem.getName();
				long l = fileItem.getSize();
				String str4 = fileItem.getContentType();
				System.out.println(l + "字节" + " " + str4);
				if ((str2 != null) && (!str2.trim().equals(""))) {
					if (str2.lastIndexOf(".") >= 0)
						str3 = str2.substring(str2.lastIndexOf("."));
					File file2 = null;
					do {
						Date date = new Date();
						SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
								"HHmmssSSS");
						str2 = simpleDateFormat.format(date);
						file2 = new File(imageSavePath + str2 + str3);
					} while (file2.exists());
					File ff = new File(imageSavePath + str2 + str3);
					try {
						fileItem.write(ff);
					} catch (Exception strException) {
						strException.printStackTrace();
					}
				}
			}
		}
		response.getWriter().print(str2 + str3);
		return "none";
	}

	public String createFileNameByDate(String paramString) {
		Date strDate = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
				"HHmmssSSS");
		String str = simpleDateFormat.format(strDate) + "."
				+ paramString;
		return str;
	}

	public String getImageSavePath() {
		String imageSavePath = PropertiesUtil.getRootpath() + uploads + File.separator
				+ this.temp_file_path;
		String str2 = getYearMonthDay();
		imageSavePath = imageSavePath + File.separator + str2;
		File file = new File(imageSavePath);
		if (!file.exists())
			file.mkdirs();
		return imageSavePath;
	}

	public String getYearMonthDay() {
		Date strDate = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
				"yyyyMMdd");
		return simpleDateFormat.format(strDate);
	}

	public File getUploadifyfile() {
		return this.uploadifyfile;
	}

	public void setUploadifyfile(File paramFile) {
		this.uploadifyfile = paramFile;
	}

	public String getUPLOADS_PATH() {
		return uploads;
	}

	public String getIMAGES_PATH() {
		return images;
	}

	public String getTemp_file_path() {
		return this.temp_file_path;
	}

	public void setTemp_file_path(String paramString) {
		this.temp_file_path = paramString;
	}

	public String getTemp_file_type() {
		return this.temp_file_type;
	}

	public void setTemp_file_type(String paramString) {
		this.temp_file_type = paramString;
	}

	public int getTemp_file_size() {
		return this.temp_file_size;
	}

	public void setTemp_file_size(int paramInt) {
		this.temp_file_size = paramInt;
	}

	public String getIMAGE_TYPE() {
		return this.IMAGE_TYPE;
	}

	public int getIMAGE_SIZE() {
		return three;
	}

	public String getUploadifyfileFileName() {
		return this.uploadifyfileFileName;
	}

	public void setUploadifyfileFileName(String paramString) {
		this.uploadifyfileFileName = paramString;
	}

	public String getIsImgControl() {
		return this.isImgControl;
	}

	public void setIsImgControl(String paramString) {
		this.isImgControl = paramString;
	}

	public String getIsYin() {
		return this.isYin;
	}

	public void setIsYin(String paramString) {
		this.isYin = paramString;
	}

	public String getIsImgControl_isYin() {
		return this.isImgControl_isYin;
	}

	public void setIsImgControl_isYin(String paramString) {
		this.isImgControl_isYin = paramString;
	}
}