spring mvc 图片上传，跨域解决 按天生成文件夹 ,删除，限制为图片代码,等相关配置
前端
部分相关代码
商品主图:
js:
callback-up.html
fs.root=data/ #fs.root=/home/dev/fs/ #fs.root=D:/fs/ #fs.domains=182=http://172.16.100.182:18080,localhost=http://localhost:8080
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans default-lazy-init="false" default-autowire="no">
<!-- 图片上传配制 -->
<bean id="fileUpload" class="com.xyt.gsm.utils.FileUpload">
<!-- 是否启用temp文件文件夹 -->
<property name="UploadTemp" value="false"/>
<!-- 是否相对路径 -->
<property name="RELATIVE_SAVE" value="true"/>
<!-- 限制大小 -->
<property name="photoSize" value="2097152"/>
<property name="otherSize" value="100000000"/>
<!-- 文件真实存放文件夹 远程server存放路径 /gsm/fs/-->
<!-- <property name="realFilePath" value="smb://gsm:gsm1234@172.16.100.182/home/"/> -->
<!-- 文件真实存放文件夹 本地server存入-->
<property name="realFilePath" value="${fs.root}"/>
<!-- 文件暂时文件夹 -->
<!-- <property name="UPLOADDIR" value="fs/temp/"/> -->
</bean>
<bean id="fileUploadServiceImp" class="com.xyt.gsm.service.fs.imp.FileUploadServiceImp">
<property name="productPhotoService" ref="productPhotoServiceImp"></property>
<property name="dictService" ref="dictService"></property>
</bean>
<!-- 绝对路径要在tomcat 做下面映射 -->
<!-- <Context path="/fs" docBase="d:/fs" /> -->
</beans>package com.xyt.gsm.utils;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFileOutputStream;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import com.xyt.gsm.constant.Fs;
import com.xyt.gsm.constant.Fs.UpoladStatus;
/**
* 图片上传
*
* @author liangrui
*
* UploadTemp 假设为false 暂时所在文件夹被实际文件夹替换,假设为true 须要再做一次拷贝
*
*/
public class FileUpload
{
// 文件信息
/** 是否启用暂时文件文件夹 */
private static boolean UploadTemp = false;
/** 文件上传相对 路径 */
private static String RELATIVEPATH = "relativePath";
/** 文件上传绝对 路径文件夹 */
private static String ABSOLUTEPATH = "absolutePath";
/** 实际文件所在文件夹 */
private static String realFilePath = "fs/";
/** 文件上传暂时所在文件夹 */
public static String UPLOADDIR = "fs/temp/";
/** 图片上传限制大小 */
public static Integer photoSize = 2097152;//
/** 末知类型文件上限制大小 */
private static Integer otherSize = 100000000;
/** 是否存放相对路径 **/
private static boolean RELATIVE_SAVE = false;
// fied
public void setUploadTemp(boolean uploadTemp)
{
UploadTemp = uploadTemp;
}
public void setPhotoSize(Integer photoSize)
{
FileUpload.photoSize = photoSize;
}
public void setOtherSize(Integer otherSize)
{
FileUpload.otherSize = otherSize;
}
public void setRealFilePath(String realFilePath)
{
if (UploadTemp == false)
UPLOADDIR = realFilePath;
FileUpload.realFilePath = realFilePath;
}
public void setUPLOADDIR(String uPLOADDIR)
{
if (UploadTemp == false)
UPLOADDIR = realFilePath;
else
UPLOADDIR = uPLOADDIR;
}
public static void setRELATIVE_SAVE(boolean rELATIVE_SAVE)
{
RELATIVE_SAVE = rELATIVE_SAVE;
}
public static String getRealFilePath() {
return realFilePath;
}
/**
*
* @param request
* 上传文件的请求
* @param suffuxDir
* 文件夹分配
* @param type
* 上传文件的类型
* @param cutPhoto
* 是否切图
* @return 上传后的文件路径
* @throws IllegalStateException
* @throws IOException
*/
// ===============================================================================================
// -----解析request 上传 返回上传后的文件把在路径
// ================================================================================================
public static List<String> fileUpload(HttpServletRequest request, String suffuxDir, String type) throws IllegalStateException, IOException
{
return fileUpload(request, suffuxDir, type, false);
}
public static List<String> fileUpload(HttpServletRequest request, String suffuxDir, String type, Boolean cutPhoto) throws IllegalStateException, IOException
{
// 上传文件的解析器
CommonsMultipartResolver mutiparRe = new CommonsMultipartResolver();
if (mutiparRe.isMultipart(request))
{// 假设是文件类型的请求
List<String> fileInfo = new ArrayList<String>();
MultipartHttpServletRequest mhr = (MultipartHttpServletRequest) request;
// 按月分文件夹
DateFormat df = new SimpleDateFormat("yyyyMM");
String month = df.format(new Date());
// 获取路径
String uploadDir = "";
if (RELATIVE_SAVE)
{
uploadDir += (request.getSession().getServletContext().getRealPath("/")+FileUpload.realFilePath);
}else
{
uploadDir += FileUpload.UPLOADDIR ;
}
uploadDir+=(suffuxDir + month + "/");
// 假设文件夹不存在，创建一个文件夹
if (!new File(uploadDir).exists())
{
File dir = new File(uploadDir);
dir.mkdirs();
}
// 跌带文件名称称
Iterator<String> it = mhr.getFileNames();
while (it.hasNext())
{
final MultipartFile mf = mhr.getFile(it.next()); // 获取一个文件
if (mf != null)
{
// 假设是图片类型文件上传 限制大小和类型
if (type.equals(Fs.FileUpLoadType.PHOTO))
{
if (!checkingPhoto(mf))
{
fileInfo.add(UpoladStatus.类型无效或图片过大.toString());
continue;
}
} else
{
if (mf.getSize() > otherSize)
{
fileInfo.add(UpoladStatus.类型无效或图片过大.toString());
continue;
}
}
// 其他上传类型 另外做限制推断
String resFileName = mf.getOriginalFilename();// 获取原文件名称
// 取得文件名称和后辍
String suffix = "";
if (resFileName.indexOf(".") != -1)
{
suffix = resFileName.substring(resFileName.lastIndexOf(".") + 1);
}
String dian = ".";
if ("".equals(suffix))
dian = "";
// 保存的文件名称
String uuid = rename();
String fileName = uuid + dian + suffix;
File outFile = new File(uploadDir + fileName); // 路径加文件名称 +"/"
mf.transferTo(outFile); // 保存到
if (cutPhoto)
{
final String dirAndUuid = uploadDir + uuid;
final String dians = dian;
final String suffixs = suffix;
new Thread(new Runnable()
{
public void run()
{
try
{
copyImgSpecification(mf.getInputStream(), dirAndUuid, dians, suffixs);
} catch (IOException e)
{
e.printStackTrace();
}
}
}).start();
}
if (RELATIVE_SAVE)
{// 相对路径文件夹
fileInfo.add("/" + FileUpload.realFilePath + suffuxDir + month + "/" + fileName);// 文件路径
} else
{// 绝对路径文件夹
fileInfo.add("/" + suffuxDir + month + "/" + fileName);// 文件路径
}
}
}
return fileInfo;
}
return null;
}
// ------------------------------------------------------------------------------------------------------------
// 复制图片 改变不同大小的规格
// ------------------------------------------------------------------------------------------------------------
public static void copyImgSpecification(InputStream is, String DirAnduuid, String dian, String suffix) throws IOException
{
Image img = ImageIO.read(is);
FileOutputStream fos = null;
for (int i = 0; i < Fs.FileUpLoadType.changePhotoSize.length; i++)
{
int w = Fs.FileUpLoadType.changePhotoSize[i];
// int h=imgSize[i];
String allPath = DirAnduuid + "_" + w + "x" + w + dian + suffix;
if ("".equals(suffix))
{
suffix = "jpg";
}
fos = new FileOutputStream(allPath); // 输出到文件流
chagePhotoSize(allPath, img, fos, suffix, w, w);
}
img.flush();
// if(fos!=null){fos.close();}
}
// ----------------------------------------------------------------
// 检查图片类型上传和图片大小
// ----------------------------------------------------------------
public static boolean checkingPhoto(MultipartFile mf) throws IOException
{
if (!isImage(mf.getInputStream()))
{ // 推断是否为图片
// fileInfo.add("请上传有效图片文件");//提示信息
return false;
}
if (mf.getSize() > photoSize)
{
// fileInfo.add("图片大于"+(new
// DecimalFormat("####.##").format(((double)photoSize)/1024/1024))+"MB上传失败");//提示信息
return false;
}
return true;
}
// 仅仅生成uuid 和后辍分开。切图时须要
public static String rename(/* String name */)
{
// 时分秒
/*
* Long now = Long.parseLong(new SimpleDateFormat("yyyyMMddHHmmss") .format(new Date()));
* Long random = (long) (Math.random() * now); String fileName = now + "" + random;
*/
// 不能设置种子值,应採用默认的方式(系统时间戳 )
final Random rd = new Random();
final Long random = rd.nextLong();
String num = String.valueOf(random);
// 限制5个字符
int limit = 5;
if (num.length() > limit)
{
num = num.substring(0, limit);
}
// uuid生成文件名称
UUID uuid = UUID.randomUUID();
// 加上 5位随机数
String uustr = uuid.toString().replace("-", "") + num;
/*
* if (name.indexOf(".") != -1) { uustr += name.substring(name.lastIndexOf(".")); } else {
* return uustr; }
*/
return uustr;
}
// 更改文件名称称
public static String rename(String name)
{
// 时分秒
/*
* Long now = Long.parseLong(new SimpleDateFormat("yyyyMMddHHmmss") .format(new Date()));
* Long random = (long) (Math.random() * now); String fileName = now + "" + random;
*/
// 不能设置种子值,应採用默认的方式(系统时间戳 )
final Random rd = new Random();
final Long random = rd.nextLong();
String num = String.valueOf(random);
// 限制5个字符
int limit = 5;
if (num.length() > limit)
{
num = num.substring(0, limit);
}
// uuid生成文件名称
UUID uuid = UUID.randomUUID();
// 加上 5位随机数
String uustr = uuid.toString().replace("-", "") + num;
if (name.indexOf(".") != -1)
{
uustr += name.substring(name.lastIndexOf("."));
} else
{
return uustr;
}
return uustr;
}
// ===============================================================================================
// -----推断是否为图片
// ================================================================================================
public static boolean isImage(File imageFile)
{
if (!imageFile.exists())
{
return false;
}
Image img = null;
try
{
img = ImageIO.read(imageFile);
if (img == null || img.getWidth(null) <= 0 || img.getHeight(null) <= 0)
{
return false;
}
return true;
} catch (Exception e)
{
return false;
} finally
{
img = null;
}
}
public static boolean isImage(InputStream imageFile)
{
Image img = null;
try
{
img = ImageIO.read(imageFile);
if (img == null || img.getWidth(null) <= 0 || img.getHeight(null) <= 0)
{
return false;
}
return true;
} catch (Exception e)
{
return false;
} finally
{
img = null;
}
}
// ===============================================================================================
// -----删除
// ================================================================================================
public static int deleteFile(HttpServletRequest request, boolean cutPhoto, String... path) throws MalformedURLException, SmbException
{
// List<String> delList=new ArrayList<String>();//记录成功删除的文件名称
int delcount = 0;
// 远程删除
if (realFilePath.length() > 3 && realFilePath.substring(0, 3).equals("smb"))
{
for (String pa : path)
{
SmbFile remoteFile = new SmbFile(pa);
if (remoteFile.exists())
{
remoteFile.delete();
delcount++;
// 获取文件名称
// delList.add(p.substring(p.lastIndexOf("/")+1));
}
}
} else
{
// 获取当前根文件夹 本地删除
String proPath = "";
if (RELATIVE_SAVE)
{
proPath += request.getSession().getServletContext().getRealPath("/");
} else
{
proPath += FileUpload.UPLOADDIR;
}
for (String p : path)
{
File file = new File(proPath + p);
if (file.exists())
{
file.delete();
delcount++;
// 获取文件名称
// delList.add(p.substring(p.lastIndexOf("/")+1));
// 删除小图
if (cutPhoto)
{
Integer[] xPhotoArr = Fs.FileUpLoadType.changePhotoSize;
for (Integer imgSize : xPhotoArr)
{
String suffixs ="";
String prefix=p;
if(p.indexOf(".")!=-1){
suffixs = p.substring(p.lastIndexOf("."));
prefix = p.substring(0, p.lastIndexOf("."));
}
String newP = prefix + "_" + imgSize + "x" + imgSize + suffixs;
File filex = new File(proPath + newP);
if (filex.exists())
{
filex.delete();
delcount++;
}
}
}
}
}
}
return delcount;
}
/**
*
* @param request
* @param path
* 暂时图片文件夹
* @param prefixDir
* 前辍文件夹 比方 "商品ID文件夹,商品图片文件夹"
* @return
* @throws IOException
*/
// -------------------------------------------------------------------------------------------
// 把temp的图片文件复制到 真实存放文件文件夹/日期文件夹中
// -----------------------------------------------------------------------------------------------
public static String tempToupdateImgPath(HttpServletRequest request, String path, String... prefixDir) throws IOException
{
// 主文件夹
String rootDir = request.getSession().getServletContext().getRealPath("/");
File file = new File(rootDir + path);// 须要移动的图片
String realPath = "";// 实际图片地址
String dbPath = "";// 保存数据库
String fileName = path.substring(path.lastIndexOf("/") + 1);// 文件名称
// 加上前辍文件夹
StringBuffer appendDir = new StringBuffer();
for (String zdir : prefixDir)
{
appendDir.append(zdir + "/");
}
// smb://username:password@192.168.0.77
// 假设是smb远程 上传远程server
if (realFilePath.length() > 3 && realFilePath.substring(0, 3).equals("smb"))
{
dbPath = fileToRemoto(file, fileName, appendDir.toString());
} else
{
// 上传到本地server
dbPath = realFilePath + appendDir.toString() + new SimpleDateFormat("yyyyMMdd").format(new Date()) + "/";
realPath = rootDir + dbPath;
if (!new File(realPath).exists())
{
File dir = new File(realPath);
dir.mkdirs();
}
file.renameTo(new File(realPath + fileName));
}
return "/" + dbPath + fileName;
}
// -------------------------------------------------------------------------------------------
// 通用smb 传送文件到远程 配制路径 前三个字符为 smb开头
// -----------------------------------------------------------------------------------------------
private static String fileToRemoto(File file, String fileName, String prefixDir)
{
InputStream in = null;
OutputStream out = null;
String returnPath = null;
try
{
// 获取流
in = new BufferedInputStream(new FileInputStream(file));
String dateDir = new SimpleDateFormat("yyyyMMdd").format(new Date()) + "/";
SmbFile remoteFile = new SmbFile(realFilePath + dateDir);
// ip+...
String fixed = realFilePath.substring(realFilePath.indexOf('@') + 1);
returnPath = fixed + prefixDir + dateDir + fileName;
if (!remoteFile.exists())
{
remoteFile.mkdirs();
}
// 将远程的文件路径传入SmbFileOutputStream中 并用 缓冲流套接
String inputFilePath = remoteFile + "/" + fileName;
// System.out.println("remoteFile: "+remoteFile);
out = new BufferedOutputStream(new SmbFileOutputStream(inputFilePath));
byte[] buffer = new byte[1024];
while (in.read(buffer) != -1)
{
out.write(buffer);
buffer = new byte[1024];
}
} catch (FileNotFoundException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
} finally
{
try
{
if (in != null)
{
in.close();
}
if (out != null)
{
out.close();
}
} catch (IOException e)
{
e.printStackTrace();
}
}
return returnPath;
}
// ----------------------------------------------------------------------------------------
// 改变图片大小
// --------------------------------------------------------------------------------------
private static void chagePhotoSize(final String path, Image src/* FileInputStream is */, FileOutputStream fos, final String format, int w, int h) throws IOException
{
try
{
int old_w = src.getWidth(null); // 得到源图宽
int old_h = src.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(,,) width - 所创建图像的宽度 height - 所创建图像的高度 imageType - 所创建图像的类型
*/
// 图片跟据长宽留白。成一个正方形图。
BufferedImage oldpic;
if (old_w > old_h)
{
// BufferedImage.TYPE_INT_RGB; //0-13
oldpic = new BufferedImage(old_w, old_w, 1);
} else
{
if (old_w < old_h)
{
oldpic = new BufferedImage(old_h, old_h, 1);
} else
{
oldpic = new BufferedImage(old_w, old_h, 1);
}
}
// 改变图片大小
Graphics2D g = oldpic.createGraphics();
g.setColor(Color.white);
if (old_w > old_h)
{
/**
* x - 要填充矩形的 x 坐标。
y - 要填充矩形的 y 坐标。 width - 要填充矩形的宽度。 height - 要填充矩形的高度。
*/
g.fillRect(0, 0, old_w, old_w);
/**
* img - 要绘制的指定图像。
假设 img 为 null，则此方法不运行不论什么操作。 x - x 坐标。
y - y 坐标。
width - 矩形的宽度。
* height - 矩形的高度。
bgcolor - 在图像非透明部分下绘制的背景色。 observer - 当转换了很多其他图像时要通知的对象。
*/
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);
/**
* getScaledInstance() width - 将图像缩放到的宽度。
height - 将图像缩放到的高度。
hints -
* 指示用于图像又一次取样的算法类型的标志。
*/
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;
BufferedImage tag = new BufferedImage(new_w, new_h, 4);
tag.getGraphics().drawImage(src.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0, 0, null);
ImageIO.write(tag, format, fos);
tag.flush();
} catch (IOException ex)
{
ex.printStackTrace();
} finally
{
if (fos != null)
{
fos.close();
}
}
}
// ==========在服务端为用户保存图片上传信息================================================
// private static final ThreadLocal<> threadLocal =new ThreadLocal<>();
}
package com.xyt.gsm.service.fs;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.xyt.gsm.bean.common.ResultBean;
import com.xyt.gsm.entity.mgr.User;
public interface FileUploadService
{
String singleUpload(HttpServletRequest request, User user, String suffixDir, String type, Boolean cutPhoto) throws Exception;//
List<?> MonyUpload(HttpServletRequest request, User user, String suffixDir);//
int deleteFile(HttpServletRequest request, boolean cutPhoto, String... path);
ResultBean deleteFileAnDb(HttpServletRequest request, String type, String id, boolean cutPhoto, String... path) throws Exception;
String singleUpload(HttpServletRequest request, User user, String suffixDir, String type, Boolean cutPhoto, String merchantId) throws Exception;//
List<String> singleUpload(HttpServletRequest request, String suffixDir, String type, Boolean cutPhoto, String merchantId) throws Exception;//
void download();
}
package com.xyt.gsm.service.fs.imp;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.xyt.gsm.bean.common.ResultBean;
import com.xyt.gsm.constant.CommonConstants;
import com.xyt.gsm.constant.DictConstants;
import com.xyt.gsm.constant.Fs;
import com.xyt.gsm.constant.Fs.UpoladStatus;
import com.xyt.gsm.entity.mgr.User;
import com.xyt.gsm.service.fs.FileUploadService;
import com.xyt.gsm.service.mgr.DictService;
import com.xyt.gsm.service.mgr.ProductPhotoService;
import com.xyt.gsm.utils.FileUpload;
public class FileUploadServiceImp implements FileUploadService
{
protected Log log = LogFactory.getLog(this.getClass().getName());
private ProductPhotoService productPhotoService;
private DictService dictService;
public void setProductPhotoService(ProductPhotoService productPhotoService)
{
this.productPhotoService = productPhotoService;
}
public void setDictService(DictService dictService)
{
this.dictService = dictService;
}
@Override
public String singleUpload(HttpServletRequest request, User user, String suffixDir, String type, Boolean cutPhoto, String merchantId) throws Exception
{
String path = "";
// 图片上传类型
if (type.equals(Fs.FileUpLoadType.PHOTO))
{
if (user == null)
return UpoladStatus.上传失败末知错误.toString();
if ("".equals(merchantId) || merchantId == null)
{
// 运营人员操作 为 还有一文件夹下
if (CommonConstants.RoleType.OPERATER.equals(user.getUserType()))
{
//merchantId = Fs.FileDir.OPERATION_DIR;
merchantId = "";
} else
{
//获取供应商id
merchantId = user.getMerchantId();
}
}
// 推断数据字典里是否有该文件夹
Map<String, String> photos = (Map<String, String>) dictService.getDictMap(DictConstants.ClsCode.FS);
if (!matchDir(photos, suffixDir))
{
// suffixDir=FileDir.NOT_DIR;
path=com.xyt.gsm.constant.Fs.UpoladStatus.文件文件夹未分配.name();
} else
{
// 商家id /处理
merchantId = manageSeparator(merchantId);
// suffixdri
suffixDir = manageSeparator(suffixDir);
path = FileUpload.fileUpload(request, merchantId + suffixDir, Fs.FileUpLoadType.PHOTO, cutPhoto).get(0);
}
}
return path;
}
@Override
public String singleUpload(HttpServletRequest request, User user, String suffixDir, String type, Boolean cutPhoto) throws Exception
{
return singleUpload(request, user, suffixDir, type, cutPhoto, "");
}
@Override
public List<?> MonyUpload(HttpServletRequest request, User user, String suffixDir)
{
// TODO Auto-generated method stub
return null;
}
@Override
public int deleteFile(HttpServletRequest request, boolean cutPhoto, String... path)
{
return 0;
}
@Override
public void download()
{
// TODO Auto-generated method stub
}
// 处理 / 前后有无/都能够
public String manageSeparator(String str)
{
if (str == null)
str = "";
if (!"".equals(str))
{// --05/01/
// 不须要/
if (str.startsWith("/"))
str = str.substring(1);
// 要加上/
if (!str.endsWith("/"))
str = str + "/";
}
return str;
}
// -------------------------------------------
// 匹配前端的文件夹和数据库的文件夹是否一至，以防前后有无/问题
// -------------------------------------------
public boolean matchDir(Map<String, String> photos, String webDir)
{
if (photos == null)
return false;
if (webDir == null)
webDir = "";
boolean isMatch = false;
if (photos.containsKey(webDir))
return true;
String temp = "";
// 不匹配的情况下！再进行前后/处理匹配
if (webDir.startsWith("/"))
{
// 前面 不要/
temp = webDir.substring(1);
if (photos.containsKey(temp))
return true;
}
if (webDir.endsWith("/"))
{
// 后面 不要/
temp = webDir.substring(0, webDir.length() - 1);
if (photos.containsKey(temp))
return true;
}
if (!webDir.endsWith("/"))
{
// 后面 要/
temp = webDir + "/";
if (photos.containsKey(temp))
return true;
}
if (!webDir.startsWith("/"))
{
// 前面 要/
temp = "/" + webDir;
if (photos.containsKey(temp))
return true;
}
// 前面 后面要/
if (!webDir.startsWith("/") && !webDir.endsWith("/"))
{
temp = "/" + webDir + "/";
if (photos.containsKey(temp))
return true;
}
// 前面 后面 不要/
if (webDir.startsWith("/") && webDir.endsWith("/"))
{
temp = webDir.substring(1, webDir.length() - 1);
if (photos.containsKey(temp))
return true;
}
return isMatch;
}
@Override
public ResultBean deleteFileAnDb(HttpServletRequest request, String type, String id, boolean cutPhoto, String... path) throws Exception
{
ResultBean rb = new ResultBean();
if (type.equals(Fs.FileUpLoadType.PHOTO))
{
// 删除数据
int count = productPhotoService.deleteByProductId(id);
if (count > 0)
{
// 删除图片
int cou = FileUpload.deleteFile(request, cutPhoto, path);
if (0 >= cou)
{
log.warn("id:" + id + ": 数据删除成功!图片删除失败");
}
} else
{
rb.setSuccess(false);
}
}
return rb;
}
@Override
public List<String> singleUpload(HttpServletRequest request,
String suffixDir, String type, Boolean cutPhoto, String merchantId)
throws Exception {
List<String> paths = null;
// 图片上传类型
if (type.equals(Fs.FileUpLoadType.PHOTO))
{
// 推断数据字典里是否有该文件夹
Map<String, String> photos = (Map<String, String>) dictService.getDictMap(DictConstants.ClsCode.FS);
if (!matchDir(photos, suffixDir))
{
// suffixDir=FileDir.NOT_DIR;
// path=com.xyt.gsm.constant.Fs.UpoladStatus.文件文件夹未分配.name();
} else
{
// 商家id /处理
merchantId = manageSeparator(merchantId);
// suffixdri
suffixDir = manageSeparator(suffixDir);
paths = FileUpload.fileUpload(request, merchantId + suffixDir, Fs.FileUpLoadType.PHOTO, cutPhoto);
}
}
return paths;
}
}
package com.xyt.gsm.mvc.controller.fs;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.google.gson.JsonObject;
import com.xyt.gsm.bean.common.ResultBean;
import com.xyt.gsm.bean.mgr.FileUploadVo;
import com.xyt.gsm.bean.mgr.LoginUser;
import com.xyt.gsm.constant.CommonConstants;
import com.xyt.gsm.constant.Fs;
import com.xyt.gsm.constant.Fs.UpoladStatus;
import com.xyt.gsm.entity.mgr.ProductPhoto;
import com.xyt.gsm.entity.mgr.User;
import com.xyt.gsm.mvc.controller.BaseController;
import com.xyt.gsm.service.fs.FileUploadService;
import com.xyt.gsm.service.ice.MerchantService;
import com.xyt.gsm.utils.FileUpload;
import com.xyt.gsm.utils.StringUtil;
/**
* 图片上传接口 controller
*
* @author liangrui
*
*/
@Controller
@RequestMapping(CommonConstants.UriPrefix.PC + CommonConstants.Menu.SYS + "/photoupload")
public class PhotoUploadController extends BaseController
{
protected Log log = LogFactory.getLog(this.getClass().getName());
@Resource
FileUploadService fileUploadService;
@Resource
MerchantService merchantService;
// 多张上传
@ResponseBody
@RequestMapping(value = "/manyup")
public List<String> ManyUp(HttpServletRequest request, HttpServletResponse response, String suffixDir) throws IllegalStateException, IOException
{
List<String> fileInfo = null;
return fileInfo;
}
// -----------------------------------------------------------------------------------
// 单张图片上传，返回路径
//@currentDomain:解决跨域。传值为==》主域server下的子页面 在子页面 周转, 回调父页面的JS函数
// ----------------------------------------------------------------------------------
@RequestMapping(value = "/singleup", method = RequestMethod.POST)
public void SingleUp(HttpServletRequest request, HttpServletResponse response, @RequestParam(value = "suffixDir", required = true) String suffixDir,
@RequestParam(required = false, value = "cutPhoto") boolean cutPhoto, @RequestParam(required = false, value = "merchantId") String merchantId) throws Exception
{
StringBuffer basePath=new StringBuffer(request.getScheme());
basePath.append("://");
basePath.append(request.getServerName());
basePath.append(":");
basePath.append(request.getServerPort());
basePath.append(request.getContextPath());
basePath.append("/");
//basePath.append(FileUpload.getRealFilePath()/*.substring(0,FileUpload.getRealFilePath().length()-1)*/);
User user = super.getLoginUser(request).getUser();
if (user != null)
{
String filePath = fileUploadService.singleUpload(request, user, suffixDir, Fs.FileUpLoadType.PHOTO, cutPhoto, merchantId);
// 处理返回状态
UpoladStatus result = getStatus(filePath);
String PromptSize = "";
if (UpoladStatus.类型无效或图片过大.toString().equals(result.toString()))
{
// 2^10=1024
PromptSize = "(最大限制:" + (FileUpload.photoSize >> 20) + "MB)";
}
PrintWriter out = response.getWriter();
response.setHeader("Cache-Control", "none-cache");
String idnum = request.getParameter("idnum");
String reutrnDate = "{'id':'" + idnum + "','filePath':'" + basePath.append(filePath).toString() + "','dbFilePath':'" + filePath + "','status':{'code':'" + result.ordinal() + "','message':'" + result.name()
+ PromptSize + "'}}";
String currentDomain = request.getParameter("currentDomain");
//<script>parent.parent.callback(" + reutrnDate + ");</script>
String ret="<iframe id="ifr" src=""+currentDomain+"#"+reutrnDate+""></iframe>";
out.print(ret);
}
}
@RequestMapping(value = "/saveImage", method = RequestMethod.POST)
public void saveImage(HttpServletRequest request, HttpServletResponse response, FileUploadVo vo) throws Exception
{
// 删除旧的没用的图片
if (!StringUtil.isEmpty(vo.getOldImagePath()) && vo.getOldImagePath().startsWith("/"))
{
FileUpload.deleteFile(request, vo.getCutPhoto(), vo.getOldImagePath());
}
User user = super.getLoginUser(request).getUser();
String filePath = fileUploadService.singleUpload(request, user, vo.getSuffixDir(), Fs.FileUpLoadType.PHOTO, vo.getCutPhoto(), vo.getMerchantId());
JsonObject json = new JsonObject();
json.addProperty("filePath", filePath);
json.addProperty("success", false);
if (!StringUtil.isEmpty(filePath) && filePath.startsWith("/"))
{
json.addProperty("success", true);
}
String result="<iframe id="ifr01001" src='"+vo.getCallbackPath()+"#"+json.toString()+"'></iframe>";
responseText(response, result);
}
/**
* 响应请求
*
* @param response
* @param result
* @throws IOException
*/
private void responseText(HttpServletResponse response, String result) throws IOException
{
response.setHeader("pragma", "no-cache");
response.setHeader("cache-control", "no-no-cache");
response.setHeader("expires", "0");
response.setContentType("text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter out = null;
try
{
out = response.getWriter();
out.print(result);
out.flush();
} finally
{
if (out != null)
{
out.close();
}
}
}
// -----------------------------------------------------------------------------------
// 商品 图片数据和存储图片 删除 依据id
// ----------------------------------------------------------------------------------
@ResponseBody
@RequestMapping(value = "/delimgandb")
public ResultBean delImgAnDB(HttpServletRequest request, HttpServletResponse response, ProductPhoto photo, @RequestParam(required = true, value = "id") String id,
@RequestParam(value = "cutPhoto", required = false) boolean cutPhoto, @RequestParam(value = "path") String path) throws Exception
{
return fileUploadService.deleteFileAnDb(request, Fs.FileUpLoadType.PHOTO, id, cutPhoto, path);
}
// -----------------------------------------------------------------------------------
// 仅仅 删除存储图片
// ----------------------------------------------------------------------------------
// @ResponseBody
@RequestMapping(value = "/delimg")
public void delImg(HttpServletRequest request, HttpServletResponse response, @RequestParam(value = "path", required = true) String[] path,
@RequestParam(value = "cutPhoto", required = false) boolean cutPhoto) throws Exception
{
if (path.length > 0)
{
FileUpload.deleteFile(request, cutPhoto, path);
}
}
// 获得图片返回状态
public UpoladStatus getStatus(String filePath)
{
UpoladStatus result = UpoladStatus.上传失败末知错误;
boolean isUp = true;
for (UpoladStatus u : UpoladStatus.values())
{
if (filePath.equals(u.toString()))
{
result = u;
isUp = false;
break;
}
}
if (isUp)
{
result = UpoladStatus.SEUCCESS;
}
return result;
}
// -----------------------------------------------------------------------------------
// 获取上传server的域名
// 依据用户类型获取，
// 假设是商家。code 为null 默认取商家商品域名, 传參数 "1" 取商家域名
// ----------------------------------------------------------------------------------
@RequestMapping(value = "/getdomain", method = RequestMethod.POST)
@ResponseBody
public String getUpPhotoDomain(HttpServletRequest request, HttpServletResponse response, String code)
{
String domain = "";
LoginUser user = super.getLoginUser(request);
if (user != null)
{
// 运营
if (CommonConstants.RoleType.OPERATER.equals(user.getUser().getUserType()))
{
domain = user.getPublicUploadDomain();
} else if (CommonConstants.RoleType.MERCHANT.equals(user.getUser().getUserType()))
{
if (null == code || "".equals(code))
{
domain = user.getMerchantProductDomain();
// 假设没有取到
if (null == domain || "".equals(domain))
{
{
// 获取域名
domain = merchantService.getMerchantDomain(user.getUser().getMerchantId()).getProductDomain();
}
} else if ("1".equals(code))
{
domain = user.getMerchantDomain();
// 假设没有取到
if (null == domain || "".equals(domain))
{
{
// 获取域名
domain = merchantService.getMerchantDomain(user.getUser().getMerchantId()).getProductDomain();
}
}
}
}
}
}
//协议://域名/项目/X目录 ====(去掉目录)
Matcher slashMatcher = Pattern.compile("/").matcher(domain);
int mIdx = 0;
while(slashMatcher.find())
{
mIdx++; if(mIdx == 4)break;
}
domain=domain.substring(0,slashMatcher.start());
/*if ("/fs".equals(domain.substring(domain.lastIndexOf("/"))))
{
domain = domain.substring(0, domain.lastIndexOf("/"));
}*/
return domain;
}
// -----------------------------------------------------------------------------------
// 下载
// ----------------------------------------------------------------------------------
}
前端
部分相关代码
商品主图:
<div class="upload" id="mainPicButton">
<form method="post" enctype="multipart/form-data" target="hidden_frame" id="formImg0">
<!-- <input type="file" name="file0" id="file0" onchange="submitUpload('0')" style="68px;height:22px;"> -->
<input type="file" name="file0" id="file0" onchange="addOnePic('#mainPicButton')" style="68px;height:22px;">
<input type="hidden" name="idnum" value="0">
<input type="hidden" name="suffixDir" value="05/01"/>
<input type="hidden" name="cutPhoto" value="true">
<iframe name='hidden_frame' id="hidden_frame" style='display:none'></iframe>
</form>
</div><th><span>商品很多其它图片:</span></th>
<td>
<div id="morePicButton">
<form method="post" enctype="multipart/form-data" target="hidden_frame" id="formImg1">
<input type="file" name="file0" id="file0" onchange="addMorePic();" style="68px;height:22px;">
<input type="hidden" name="idnum" value="0">
<input type="hidden" name="suffixDir" value="05/01"/>
<input type="hidden" name="cutPhoto" value="true">
<iframe name='hidden_frame' id="hidden_frame" style='display:none'></iframe>
</form>
</div>js:
//全局常量
var maxNoOfPics = 5;
var picPrefix = "/fs"; //图片路径前缀
//全局变量
var imgNum = 0; //图片数量
var imgNo=0; //图片ID
var hasMainPic = false;
var origPics = new Array(); //当更新某商品时。保存原来图片的路径，用于在删除时推断是否须要延迟删除
//var domainStr=window.top.getLoginUser().merchantProductDomain;
function getDomain(){
var domainSt="";
var userObj=window.top.getLoginUser();
if(userObj.user.userType=="0")
{
domainSt=userObj.publicUploadDomain;
}else if(userObj.user.userType=="2"){
domainSt=userObj.merchantProductDomain;
}
// alert (domainSt);
return domainSt;
}
function submitUpload(id){
$("#imgSrc" + id +"").attr("alt", "图片上传中……");
var imgID = id;
if(id>0){
imgID = 1;
}
var form=document.getElementById("formImg" + imgID +"");
form.method = "post";
form.idnum.value = id;
var uriUp= getDomain()+"/pc/sys/photoupload/singleup?"+window.top.getLoginUser().token;
form.action = uriUp;
//form.action = getContextPath()+"/pc/sys/photoupload/singleup"; //必须先包括sys.js文件
//用于返回
var currentHref=window.location.href;
var subHref=currentHref.substring(0, currentHref.lastIndexOf("/"));
var input_domain = document.createElement("input");
input_domain.setAttribute("name", "currentDomain");
input_domain.setAttribute("value", subHref+"/callback-up.html");
input_domain.setAttribute("type", "hidden");
form.appendChild(input_domain);
form.submit();
//假设已经存在的图不是原图，则把server中的图片删除
var currentPicPath = $("#imgUrl" + id +"").val();
if(!contains(origPics, currentPicPath) && currentPicPath!=""){
delImg(currentPicPath, true);//true 删除图片
}
};
// step2: 上传图片。后台回调
function callback(message) {
var id=message.id;
if(message.status.code=="0"){
var filePath=message.filePath;
var dbFilePath=message.dbFilePath;
//$("#imgUrl" + id +"").attr("value", dbFilePath);
$("#imgUrl" + id +"").val(dbFilePath);
$("#imgSrc" + id +"").attr("src", filePath);
}else{
if(id!=0){
$("#imgSrc" + id).parent().remove();
}
_message(message.status.message); //上传错误提示
}
};
function deleteOrigPics(photoList){ //推断是否须要删除原图，假设原图不在photoList中，则删除
for(var i=1; i<origPics.length; i++){
var found=false;
var j=0;
while(!found && j<photoList.length){
if(photoList[j].url==origPics[i]){
found=true;
}
j++;
}
if(!found){
delImg(origPics[i], true);
}
}
}
/**
* Author: 许继俊, 2014-04
* 为“很多其它图片”添加一个图片。加在morePicButtonId前面
* morePicButtonId: “加入图片”button的ID。调用此方法就在它前面加入一个图片
* imgNo：图片序号
* picPrefix: 图片路径前缀
* filePath：图片（相对）路径
*/
//dbFilePath 用于存放数据库， fullFilePath用于显示图片
function addOnePic(picButtonId, dbFilePath, fullFilePath){
if(picButtonId == "#mainPicButton"){ //假设是主图
imgId = 0;
}else{ //假设是“很多其它图片”
imgNo++;
imgNum++;
imgId = imgNo;
}
if(picButtonId == "#mainPicButton" ){
if(hasMainPic == false){
var html = '<span class="pict">
<img id="imgSrc' + imgId + '" width="120px" height="120px"/>
<a class="close" onclick="removeImg('' + imgId + '')"></a>
<input type="hidden" id="imgUrl' + imgId + '"/></span>';
$(picButtonId).after(html);
hasMainPic = true;
}
}else{
var html = '<span class="pict">
<img id="imgSrc' + imgId + '" width="120px" height="120px"/>
<a class="close" onclick="removeImg('' + imgId + '')"></a>
<input type="hidden" class="imgUrl" id="imgUrl' + imgId + '"/></span>';
$(picButtonId).after(html);
}
if(fullFilePath != undefined){
$("#imgUrl" + imgId +"").val(dbFilePath);
$("#imgSrc" + imgId +"").attr("src", fullFilePath);
}else{
submitUpload(imgId); //假设仅仅有一个參数。则是提交
}
}
//加入很多其它图片：
function addMorePic(){
if(imgNum>=maxNoOfPics){
_message("对不起。最多仅仅能上传" + maxNoOfPics + "张图片！
");
return false;
}
addOnePic("#morePicButton");
}
//删除图片（imgNo=0时为主图）
function removeImg(imgNo){
var picPath="";
if($("#imgUrl"+ imgNo).val()!=undefined){
picPath=$("#imgUrl"+ imgNo).val();
$("#imgSrc" + imgNo).parent().remove();
}
if(imgNo==0){ //删除主图
hasMainPic = false;
//$("#imgSrc0").removeAttr("src");
//$("#imgSrc0").attr("alt","点击加入图片");
//$("#imgUrl0").removeAttr("value");
}else{ //删除其它图
imgNum--;
}
//假设是原图。则延迟server的删除（在提交时再删除）
if(picPath != origPics[imgNo]){
delImg(picPath,true);//true 删除小图
}
}
//删除图片
function delImg(path, cutPhoto){
var reqStr=null;
if(cutPhoto==true){
reqStr="path="+path+"&cutPhoto=true";
}else{
reqStr="path="+path+"&cutPhoto=false";
}
$.post(
getContextPath()+"/pc/sys/photoupload/delimg",
reqStr,
function(data){ },
'json'
);
}
/**推断在数组中是否含有给定的一个变量值/对象
* array: 数组
* obj: 值/对象
*/
function contains(array, obj) {
for (var i = 0; i < array.length; i++) {
if (array[i] === obj) {
return true;
}
}
return false;
}
callback-up.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title></title>
</head>
<body>
<script type="text/javascript">
//alert(document.domain);
var returndata=self.location.hash.substring(1);
if(parent.parent&&parent.parent.callback){
var message = eval('(' + returndata + ')');
parent.parent.callback(message);
}else if(window.top.success){
window.top.success(returndata);
}else if(parent.parent&&parent.parent.success){
parent.parent.success(returndata);
}
</script>
</body>
</html>