实现头像的上传

jsp：

上传jsp上的头像

<div class="factoryLogo">
<img <c:if test="${sessionFactory.factoryLogo == null}">src="static/img/factoryHeader.jpg"</c:if>
<c:if test="${sessionFactory.factoryLogo != null}">src="factory/imageShowSimple?seq=${sessionFactory.factoryLogo}"</c:if>
class="img-rounded" id="headerPic">
<a id="portraitUpload" href="#" onclick="return false;">上传企业logo</a>
<input id="portraitFile" type="file" name="portraitFile" onchange="portraitFileUpload()"/>
</div>

在js中：

实现portraitFileUpload

function imgCheck(filepath){
var extStart = filepath.lastIndexOf(".");
var ext = filepath.substring(extStart, filepath.length).toUpperCase();
if (ext != ".PNG" && ext != ".JPG") {
showMessage("图片只支持png,jpg格式");
return false;
}
return true;
}

-----------------------------------------------------------------------------------------------------------

function portraitFileUpload(){

if(!imgCheck($("#portraitFile").val())){
return false;
}
$.ajaxFileUpload({
type: "POST",
url:'factory/uploadPortrait',
secureuri:false,
fileElementId:'portraitFile',
dataType: 'json',
success: function(data,status){
if(data.result == "success"){
if(data.imgSeq != null){
$("#headerPic").attr("src","factory/imageShowSimple?seq="+data.imgSeq);
}
$(window.parent.document).contents().find("#touxiangWelcomeImg").attr("src", "factory/imageShowSimple?seq="+data.imgSeq);
showMessage("头像上传成功");
} else {
showMessage("头像" + data.result);
}
$("#portraitFile").replaceWith('<input id="portraitFile" name="portraitFile" type="file" onchange="portraitFileUpload()"/>');
},
error: function(data,status,e){
showMessage("头像上传异常");
}
});
}

controller：

@RequestMapping("uploadPortrait")
@ResponseBody
public Object uploadPortrait(HttpSession httpSession,HttpServletRequest request) throws IOException {
logBefore(logger, "factory/uploadPortrait");

MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("portraitFile");// 获取上传文件名

Map<String, Object> map = new HashMap<String, Object>();
byte[] imgWeb = new byte[(int)file.getSize()];
imgWeb = file.getBytes();

int size = file.getInputStream().available() / 1024;

// 大于8M不予受理
if(size > 8 * 1024){
map.put("result", "图片文件不得大于8M");
return JSON.toJSONString(map,true);
}

imgWeb = imgWebCompress(size,request,file,map,imgWeb);

FactoryFactoryInfo factoryInfo = (FactoryFactoryInfo) request.getSession().getAttribute(
Const.SESSION_FACTORY);
String factoryId = String.valueOf(factoryInfo.getFactoryId());

//上传图片 调用接口保存头像以及获取头像ID
UploadPictureParam picParam = new UploadPictureParam();
UploadPictureResult picResult = new UploadPictureResult();

picParam.setFactoryId(String.valueOf(factoryId));
picParam.setDifferent(FactoryConsts.STRING_WEB_ONE);//web
picParam.setDiffPicture(FactoryConsts.CHAR_PIC_HEAD);//头像
picParam.setImgWeb(imgWeb);
picParam.setPictureName("portraitFile");

picResult = factoryInfoService.uploadPicture(picParam);
//String imgSeq = null;

if(picResult != null && "0".equals(picResult.getResult())){
//获取企业头像地址
WriteFactoryPictureParam wfpParam = new WriteFactoryPictureParam();
wfpParam.setFactoryId(factoryId);
wfpParam.setPostfix("JPG");
WriteFactoryPictureResult wfpResult = new WriteFactoryPictureResult();
wfpResult = jobInfoService.writeFactoryPicture(wfpParam);
//企业头像地址
String url = "";
if(wfpResult != null && "0".equals(wfpResult.getResult())){
url = wfpResult.getUrl();
}
FactorySaveBaseInfoParam UpParam = new FactorySaveBaseInfoParam();
FactorySaveBaseInfoResult UpResult = new FactorySaveBaseInfoResult();
UpParam.setFactoryId(Long.valueOf(factoryId));
UpParam.setFactoryLogoPath(url);
UpParam.setUpdateUser(factoryId);
UpParam.setKbn("3");
UpResult = factoryInfoService.updateFactoryInfo(UpParam);

//获取头像ID
FactoryFactoryInfoParam infoParam = new FactoryFactoryInfoParam();
FactoryFactoryInfoResult infoResult = new FactoryFactoryInfoResult();
infoParam.setFactoryId(String.valueOf(factoryId));
infoParam.setDifferent(FactoryConsts.STRING_WEB_ONE); //web
infoResult = factoryInfoService.factoryInfo(infoParam);

map.put("imgSeq", String.valueOf(infoResult.getFactoryInfoEx().getFactoryLogo()));

httpSession.setAttribute(Const.SESSION_FACTORY, infoResult.getFactoryInfoEx());

map.put("result", "success");
}else{
map.put("result", "上传图片失败");
}
return JSON.toJSONString(map,true);
}

/**
* 图片压缩
*
* @param
* @return
* @throws IOException
* @throws Exception
*/
private byte[] imgWebCompress(int size,HttpServletRequest request,MultipartFile file,Map<String, Object> map,byte[] imgWeb) throws IOException{

// 大于100K压缩
if(size > FactoryConsts.INT_100){

CommonsMultipartFile cf= (CommonsMultipartFile)file;

DiskFileItem fi = (DiskFileItem)cf.getFileItem();

File oldFile = fi.getStoreLocation();
// 创建新的文件
String path = request.getSession().getServletContext().getRealPath("/") + "files" + File.separator + "temp" + File.separator;

File newZipFile = new File(path + String.valueOf(System.currentTimeMillis()) + ".jpg");

if (!newZipFile.exists()) {
newZipFile.createNewFile();
}

FactoryImageZipService.zipImageFile(oldFile, newZipFile, 600, 600);

imgWeb = getImageFileByte(newZipFile);
}else{

imgWeb = new byte[(int)file.getSize()];

imgWeb = file.getBytes();
}
return imgWeb;
}

/**
* 获取图片文件的数组
*
* @param filePath
* @return
*/
@SuppressWarnings("finally")
private byte[] getImageFileByte(File file){

FileInputStream fin = null;

byte[] content = null;

try {
fin = new FileInputStream(file);
ByteBuffer nbf = ByteBuffer.allocate((int) file.length());
byte[] array = new byte[1024];
int length = 0;
while ((length = fin.read(array)) > 0) {
if (length != 1024) {
nbf.put(array, 0, length);
} else {
nbf.put(array);
}
}
// 图片数组
content = nbf.array();
} catch (FileNotFoundException e) {
logger.info("文件不存在");
e.printStackTrace();
} catch (IOException e) {
logger.info("文件读写异常");
e.printStackTrace();
} finally {
// 关闭流
try {
if (fin != null) {
fin.close();
}
} catch (IOException e) {
logger.info("文件关闭异常");
e.printStackTrace();
} finally{
// 删除临时文件
if(file.exists()){
file.delete();
}
return content;
}
}
}

FactoryImageZipService文件调用

package service.factory;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;

import org.springframework.web.multipart.MultipartFile;

public class FactoryImageZipService {

/**
* 等比例压缩图片文件<br> 先保存原文件，再压缩、上传
* @param oldFile  要进行压缩的文件
* @param newFile  新文件
* @param width  宽度 //设置宽度时（高度传入0，等比例缩放）
* @param height 高度 //设置高度时（宽度传入0，等比例缩放）
* @param quality 质量
* @return 返回压缩后的文件的全路径
*/
public static String zipImageFile(File oldFile, File newFile, int width, int height) {
if (oldFile == null) {
return null;
}
try {
/** 对服务器上的临时文件进行处理 */
BufferedImage srcFile = ImageIO.read(oldFile);

// 判断图片背景是否为透明
if (srcFile.getTransparency() == Transparency.TRANSLUCENT) {
// 去掉透明背景，设置为白色
srcFile = get24BitImage(srcFile, Color.WHITE);
}
// 原图片宽
int oldImageWidth = srcFile.getWidth(null);
// 原图片高
int olgImageHight = srcFile.getHeight(null);
// 图片比率
double imageRate;

if (width > 0) {
imageRate = width / (double) oldImageWidth;
height = (int) (olgImageHight * imageRate);
} else {
if (height > 0) {
imageRate = height / (double) olgImageHight;
width = (int) (oldImageWidth * imageRate);
}
}
/** 宽,高设定 */
BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

tag.getGraphics().drawImage(srcFile.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);

/** 压缩之后临时存放位置 */
FileOutputStream out = new FileOutputStream(newFile);

ImageIO.write(tag,  "jpeg" , new File(newFile.getPath()));

out.flush();
out.close();

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return newFile.getAbsolutePath();
}

/**
* 按宽度高度压缩图片文件<br> 先保存原文件，再压缩、上传
* @param oldFile  要进行压缩的文件全路径
* @param newFile  新文件
* @param width  宽度
* @param height 高度
* @param quality 质量
* @return 返回压缩后的文件的全路径
*/
public static void zipWidthHeightImageFile(Image image,File newFile, int width, int height) {
if (image == null) {
return;
}
try {
/** 宽,高设定 */
BufferedImage tag = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);
tag.getGraphics().drawImage(image, 0, 0, width, height, null);
/** 压缩之后临时存放位置 */
FileOutputStream out = new FileOutputStream(newFile);

ImageIO.write(tag, "jpg", out);

out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 根据质量和宽高压缩图片
*
* @param file
* @param newFile
*/
public static void zipQualityImageFile(MultipartFile file, File newFile) {
// 如果文件为NULL返回
if (file == null) {
return;
}
try {
Image image = ImageIO.read(file.getInputStream());
int w = image.getWidth(null);
int h = image.getHeight(null);
int width = (int)(0.3 * w);
int height = (int)(0.3 * h);

/** 宽,高设定 */

double rate1 = ((double) image.getWidth(null)) / (double) width + 0.1;
double rate2 = ((double) image.getHeight(null)) / (double) height + 0.1;
// 根据缩放比率大的进行缩放控制
double rate = rate1 > rate2 ? rate1 : rate2;
int newWidth = (int) (((double) image.getWidth(null)) / rate);
int newHeight = (int) (((double) image.getHeight(null)) / rate);

BufferedImage tag = new BufferedImage(newWidth, newHeight,BufferedImage.TYPE_4BYTE_ABGR);

for (int i = 0; i < newWidth; i++) {
for (int j = 0; j < newHeight; j++) {
int rgb = tag.getRGB(i, j);
if (isBackPixel(rgb)) {
tag.setRGB(i, j, 0);
}
}
}

tag.getGraphics().drawImage(image, 0, 0, newWidth, newHeight, null);
/** 压缩之后临时存放位置 */
FileOutputStream out = new FileOutputStream(newFile);
// 指定写图片的方式为 jpg
ImageWriter imgWrier = ImageIO.getImageWritersByFormatName("png").next();

ImageWriteParam imgWriteParams = new javax.imageio.plugins.jpeg.JPEGImageWriteParam(null);
// 要使用压缩，必须指定压缩方式为MODE_EXPLICIT
imgWriteParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
// 将压缩质量设置为 0 和 1 之间的某个值。
imgWriteParams.setCompressionQuality((float)0.1);
// 指定 writer 使用逐步模式写出图像，从而输出流将包含一系列质量递增的扫描。
imgWriteParams.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
ColorModel colorModel = ColorModel.getRGBdefault();
// 指定压缩时使用的色彩模式
imgWriteParams.setDestinationType(new javax.imageio.ImageTypeSpecifier(colorModel, colorModel
.createCompatibleSampleModel(width, height)));
imgWrier.reset();
// 必须先指定 out值，才能调用write方法, ImageOutputStream可以通过任何 OutputStream构造
imgWrier.setOutput(ImageIO.createImageOutputStream(out));
// 调用write方法，就可以向输入流写图片
imgWrier.write(null, new IIOImage(tag, null, null), imgWriteParams);

out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 判断当前像素是否为黑色不透明的像素（-16777216）
* @param pixel 要判断的像素
* @return 是背景像素返回true，否则返回false
*/
private static boolean isBackPixel(int pixel) {
int back[] = { -16777216 };
for (int i = 0; i < back.length; i++) {
if (back[i] == pixel){
return true;
}
}
return false;
}

/**
* 去掉PNG的透明背景设置为白色
*
* @param image
* @param bgColor
* @return
*/
private static BufferedImage get24BitImage(BufferedImage image, Color bgColor) {

int width = image.getWidth();

int height = image.getHeight();

BufferedImage newImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

Graphics2D graphic = newImage.createGraphics();

graphic.setColor(bgColor);

graphic.fillRect(0, 0, width, height);

graphic.drawRenderedImage(image, null);

graphic.dispose();

return newImage;
}
}

文件图片的上传就OK了，接下来是图片的显示

jsp页面中的 src="factory/imageShowSimple?seq=${sessionFactory.factoryLogo}

package controller.factory;

import java.io.IOException;

import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import model.factory.base.FactoryImageInfo;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import service.factory.FactoryImageInfoService;
import controller.base.BaseController;

@Controller
public class FactoryImageDisplayControll extends BaseController{

@Resource
private FactoryImageInfoService factoryImageInfoService;

@RequestMapping("factory/imageShowSimple")
public void imageShowSimple(HttpServletResponse response, String seq){

FactoryImageInfo imageInfo = null;

ServletOutputStream output = null;

try {
// 查询图片信息表
if(seq != null && !"".equals(seq)){
imageInfo = factoryImageInfoService.selectByPrimaryKey(Integer.parseInt(seq));
}
// 将图片写入画面
if(imageInfo != null){

output=response.getOutputStream();

byte[] imageBytes = imageInfo.getImageBlob();

output.write(imageBytes);
}
} catch (IOException e) {
logger.info("操作失败");
e.printStackTrace();
} catch (Exception e) {
logger.info("转化失败");
e.printStackTrace();
} finally{
try {
if(output != null){
output.close();
}
} catch (IOException e) {
logger.info("数据流关闭异常");
e.printStackTrace();
}
}

}
}

结束~