struts2图片上传以及显示

Java 后台代码

package com.doone.ssp.mgr.commodity.action;

import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
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.math.BigDecimal;
import java.util.Date;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.imageio.ImageIO;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.StrutsStatics;
import org.springframework.beans.factory.annotation.Autowired;

import com.doone.comm.struts.BaseAction;
import com.doone.ssp.commodity.entity.CommodityDirectory;
import com.doone.ssp.commodity.entity.CommodityPicture;
import com.doone.ssp.commodity.entity.CommodityPictureGroup;
import com.doone.ssp.commodity.entity.CommodityTerminals;
import com.doone.ssp.commodity.entity.GoodsParam;
import com.doone.ssp.commodity.entity.SpecificationGroup;
import com.doone.ssp.commodity.service.CommoditDirectoryService;
import com.doone.ssp.commodity.service.CommodityPictureService;
import com.doone.ssp.commodity.service.CommoditySpecificationService;
import com.doone.ssp.commodity.service.CommodityTerminalsService;
import com.opensymphony.xwork2.ActionContext;

public class TerminalsAction extends BaseAction {
 Logger log = Logger.getLogger(TerminalsAction.class);
 
 private static final long serialVersionUID = 1L;
 private static final int BUFFER_SIZE = 16 * 1024 ;
 @Autowired
 private CommodityTerminalsService remoteTerminalsService;
 
 @Autowired
 private CommoditDirectoryService remoteCommonDirectoryService;
 @Autowired
 private CommoditySpecificationService remoteCommoditySpecificationService;
 
 @Autowired
 private CommodityPictureService remoteCommodityPictureService;

 private CommodityTerminals commodityTerminals;
 
 private Integer id;
 
 private String commondityCode;
 
 private String goodsType;
 
 private CommodityDirectory commodityDirectory;
 
 private String commondityName;
 
 private String promotePhrases;
 
 private Integer singleRestricted;
 
 private Date topCarriageTime;
 
 private Date underCarriageTime;
 
 private BigDecimal market;
 
 private BigDecimal mallprice;
 
 private Integer warningAmout;
 private InputStream inputStream;

 //详细信息---------
 
 //商品介绍
 private String commodityIntroduce;
 //包装清单
 private String packingList;
 //赠品
 private String gift;
 //售后服务说明
 private String aftersalesService;
 
 
 //图片
 private String pictureName;
    //商品参数信息
  public Map<String, Spe> spes ;
   //图片数据
  private File[] upload;

  private String[] uploadFileName;
 
  private String[] uploadContentType; 
  
  private Integer pictureId;
 
 
 public InputStream getInputStream() {
  return inputStream;
 }

 public void setInputStream(InputStream inputStream) {
  this.inputStream = inputStream;
 }

 public String[] getUploadFileName() {
  return uploadFileName;
 }

 public void setUploadFileName(String[] uploadFileName) {
  this.uploadFileName = uploadFileName;
 }

 public String[] getUploadContentType() {
  return uploadContentType;
 }

 public void setUploadContentType(String[] uploadContentType) {
  this.uploadContentType = uploadContentType;
 }

 public File[] getUpload() {
  return upload;
 }

 public void setUpload(File[] upload) {
  this.upload = upload;
 }

 public Map<String, Spe> getSpes() {
  return spes;
 }

 public void setSpes(Map<String, Spe> spes) {
  this.spes = spes;
 }

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public CommodityTerminals getCommodityTerminals() {
  return commodityTerminals;
 }

 public void setCommodityTerminals(CommodityTerminals commodityTerminals) {
  this.commodityTerminals = commodityTerminals;
 }

 public CommodityDirectory getCommodityDirectory() {
  return commodityDirectory;
 }

 public void setCommodityDirectory(CommodityDirectory commodityDirectory) {
  this.commodityDirectory = commodityDirectory;
 }

 public String getPictureName() {
  return pictureName;
 }

 public void setPictureName(String pictureName) {
  this.pictureName = pictureName;
 }

 public String getGoodsType() {
  return goodsType;
 }

 public void setGoodsType(String goodsType) {
  this.goodsType = goodsType;
 }

 public CommodityTerminalsService getRemoteTerminalsService() {
  return remoteTerminalsService;
 }

 public void setRemoteTerminalsService(
   CommodityTerminalsService remoteTerminalsService) {
  this.remoteTerminalsService = remoteTerminalsService;
 }

 public String getCommondityCode() {
  return commondityCode;
 }

 public void setCommondityCode(String commondityCode) {
  this.commondityCode = commondityCode;
 }

 public String getCommondityName() {
  return commondityName;
 }

 public void setCommondityName(String commondityName) {
  this.commondityName = commondityName;
 }

 public String getPromotePhrases() {
  return promotePhrases;
 }

 public void setPromotePhrases(String promotePhrases) {
  this.promotePhrases = promotePhrases;
 }

 public Integer getSingleRestricted() {
  return singleRestricted;
 }

 public void setSingleRestricted(Integer singleRestricted) {
  this.singleRestricted = singleRestricted;
 }

 public Date getTopCarriageTime() {
  return topCarriageTime;
 }

 public void setTopCarriageTime(Date topCarriageTime) {
  this.topCarriageTime = topCarriageTime;
 }

 public Date getUnderCarriageTime() {
  return underCarriageTime;
 }

 public void setUnderCarriageTime(Date underCarriageTime) {
  this.underCarriageTime = underCarriageTime;
 }

 public BigDecimal getMarket() {
  return market;
 }

 public void setMarket(BigDecimal market) {
  this.market = market;
 }

 public BigDecimal getMallprice() {
  return mallprice;
 }

 public void setMallprice(BigDecimal mallprice) {
  this.mallprice = mallprice;
 }

 public Integer getWarningAmout() {
  return warningAmout;
 }

 public void setWarningAmout(Integer warningAmout) {
  this.warningAmout = warningAmout;
 }
 
 public String show_addTerminals()throws Exception{
  
  return "showAddTerminals";
 }
 
 
 public String getAftersalesService() {
  return aftersalesService;
 }

 public void setAftersalesService(String aftersalesService) {
  this.aftersalesService = aftersalesService;
 }

 public String getCommodityIntroduce() {
  return commodityIntroduce;
 }

 public void setCommodityIntroduce(String commodityIntroduce) {
  this.commodityIntroduce = commodityIntroduce;
 }

 public String getPackingList() {
  return packingList;
 }

 public void setPackingList(String packingList) {
  this.packingList = packingList;
 }

 public String getGift() {
  return gift;
 }

 public void setGift(String gift) {
  this.gift = gift;
 }

 
 
 public Integer getPictureId() {
  return pictureId;
 }

 public void setPictureId(Integer pictureId) {
  this.pictureId = pictureId;
 }

 public String next_page_method()throws Exception{
  
  CommodityTerminals commodityTerminals =new CommodityTerminals();
  
  commondityCode = this.getCommondityCode();
  goodsType = this.getGoodsType();
  commondityName = this.getCommondityName();
  promotePhrases = this.getPromotePhrases();
  singleRestricted = this.getSingleRestricted();
  topCarriageTime = this.getTopCarriageTime();
  underCarriageTime = this.getUnderCarriageTime();
  market = this.getMarket();
  mallprice = this.getMallprice();
  warningAmout = this.getWarningAmout();
  
  int directoryId = Integer.parseInt(goodsType);
  commodityDirectory = remoteCommonDirectoryService.getDirectoryById(directoryId);
  
  List<SpecificationGroup> specificationGrouplist=remoteCommoditySpecificationService.listSpecificationGroupByDirectoryId(directoryId);
  //根据目录信息获取参数组
  commodityTerminals.setSpecificationGrouplist(specificationGrouplist);
  
  commodityTerminals.setCommondityCode(commondityCode);
  commodityTerminals.setCommondityName(commondityName);
  commodityTerminals.setCommodityDirectory(commodityDirectory);
  commodityTerminals.setPromotePhrases(promotePhrases);
  commodityTerminals.setSingleRestricted(singleRestricted);
  commodityTerminals.setTopCarriageTime(topCarriageTime);
  commodityTerminals.setUnderCarriageTime(underCarriageTime);
  commodityTerminals.setMarket(market);
  commodityTerminals.setMallprice(mallprice);
  commodityTerminals.setWarningAmout(warningAmout);
  HttpServletRequest request = (HttpServletRequest) ActionContext
  .getContext().get(StrutsStatics.HTTP_REQUEST);
        request.setAttribute("specificationGrouplist", specificationGrouplist); 
    
       
  
  
  id = remoteTerminalsService.insertTerminals(commodityTerminals);
  return "next_page_method";
 }
 
  
 public String list_page() throws Exception{
  CommodityTerminals commodityTerminals =new CommodityTerminals();
  
  commondityCode = this.getCommondityCode();
  goodsType = this.getGoodsType();
  commondityName = this.getCommondityName();
  promotePhrases = this.getPromotePhrases();
  singleRestricted = this.getSingleRestricted();
  topCarriageTime = this.getTopCarriageTime();
  underCarriageTime = this.getUnderCarriageTime();
  market = this.getMarket();
  mallprice = this.getMallprice();
  warningAmout = this.getWarningAmout();
  
  int directoryId = Integer.parseInt(goodsType);
  commodityDirectory = remoteCommonDirectoryService.getDirectoryById(directoryId);
  
  commodityTerminals.setCommondityCode(commondityCode);
  commodityTerminals.setCommondityName(commondityName);
  commodityTerminals.setCommodityDirectory(commodityDirectory);
  commodityTerminals.setPromotePhrases(promotePhrases);
  commodityTerminals.setSingleRestricted(singleRestricted);
  commodityTerminals.setTopCarriageTime(topCarriageTime);
  commodityTerminals.setUnderCarriageTime(underCarriageTime);
  commodityTerminals.setMarket(market);
  commodityTerminals.setMallprice(mallprice);
  commodityTerminals.setWarningAmout(warningAmout);
  
  remoteTerminalsService.insertTerminals(commodityTerminals);
  return "list_page";
 }
 
 public String keepmessage() throws Exception{
  //取得所有参数项
    log.info("--------开始获取参数----------");
    if(null!=spes&&spes.size()>0){
     Set<String> sets=spes.keySet();
     log.info("--------取得所有参数项----------");
      if(sets.size()>0){
       for(String key:sets){
        //添加商品参数映射信息
        GoodsParam goodsParam=new GoodsParam();
        goodsParam.setCreateDate(new Date());
        goodsParam.setGoodsId(id);
        goodsParam.setGroupId(spes.get(key).getGroupId());
        goodsParam.setGroupName(spes.get(key).getGroupName());
        goodsParam.setItemId(spes.get(key).getItemId());
        goodsParam.setItemName(spes.get(key).getItemName());
        goodsParam.setItemValue(spes.get(key).getItemValue());
        remoteTerminalsService.insertGoodsParam(goodsParam);     
       }
      }
    }
     log.info("--------添加终端参数参数完毕----------");      
  commodityTerminals=remoteTerminalsService.queryTerminalsById(id);
  commodityIntroduce=this.getCommodityIntroduce();
  packingList=this.getPackingList();
  gift=this.getGift();
  aftersalesService=this.getAftersalesService();
  commodityTerminals.setCommodityIntroduce(commodityIntroduce);
  commodityTerminals.setPackingList(packingList);
  commodityTerminals.setGift(gift);
  commodityTerminals.setAftersalesService(aftersalesService);
  remoteTerminalsService.updateTerminals(commodityTerminals);
  return "keepmessage";
 }
 
 public String addPicture(){
   try {
        
         log.info("--------获得商品基本信息----------"); 
         commodityTerminals=remoteTerminalsService.queryTerminalsById(id);
      log.info("--------保存图片组开始----------"); 
            CommodityPictureGroup commodityPictureGroup=new CommodityPictureGroup();
      commodityPictureGroup.setIsDefault(false);
      commodityPictureGroup.setPictureGroupName(pictureName);
      commodityPictureGroup.setCommoditySpec(id);
      Integer picturGroupId=remoteCommodityPictureService.insertcommodityPictureGroup(commodityPictureGroup);
      commodityPictureGroup.setPictureGroupId(picturGroupId);
      log.info("--------保存图片---------"); 
    for(int i=0;i<uploadFileName.length;i++){
      String message=checkImage(upload[i],i);
      if(message.equals("SUCCESS")){
       log.info("--------图片张数---------"+uploadFileName.length+"================");
       String newFileName =(4-i)+getExtention(uploadFileName[i]);
       log.info("--------构造图片转存地址---------");
       String newFilePath=ServletActionContext.getServletContext().getRealPath("/UploadImages")+"/"+new Date().getTime()+ newFileName;   
       File   newFile=upload[i]; 
       log.info("--------把文件转成byte数组---------"); 
       byte [] fileByte=fileToByteArray(newFile);
       File imageFile = new File(newFilePath);
       //把文件转存到相应目录
       log.info("--------把文件转存到相应目录---------"); 
       copy(newFile, imageFile);
       log.info("--------开始构造图片对象---------"); 
       CommodityPicture commodityPicture=new CommodityPicture();
       commodityPicture.setPictureGroup(commodityPictureGroup);
       commodityPicture.setPictureName(newFileName);
       commodityPicture.setPicturePath(id+"/"+picturGroupId+"/"+newFileName) ;
       commodityPicture.setPictureData(fileByte);
       commodityPicture.setPictureSize1(4-i);
      //保存图片到数据库
       log.info("--------保存图片到数据库---------"); 
       remoteCommodityPictureService.insertCommodityPicture(commodityPicture);
      }else {
       log.info("--------如果图片尺寸不满足要求就删除本次所插入的图片组以及图片---------"); 
       remoteCommodityPictureService.deleteCommodityPictureGroupById(picturGroupId);
       remoteCommodityPictureService.deleteCommodityPictureByGroupId(picturGroupId);
       addFieldError("message",message);
       log.info("--------根据商品ID查询最小的图片组列表---------"); 
       List <CommodityPictureGroup> commodityPictureGroupList= remoteCommodityPictureService.listCommodityPictureGroupByCommodityId(id);
       log.info("id="+id+"--------获取所有组--------"+commodityPictureGroupList.size());
       List <CommodityPicture> listSmallCommodityPicture=new ArrayList<CommodityPicture>();
       log.info("--------获取所有组下面的最小图片--------");
       for(CommodityPictureGroup group:commodityPictureGroupList){
        CommodityPicture c= remoteCommodityPictureService.getSmallCommodityPictureByGroupId(group.getPictureGroupId());
        listSmallCommodityPicture.add(c);
       }
       HttpServletRequest request = (HttpServletRequest) ActionContext
      .getContext().get(StrutsStatics.HTTP_REQUEST);
       request.setAttribute("listSmallCommodityPicture", listSmallCommodityPicture);
       log.info("--------最小图片保存到一个集合完毕返回页面--------");
       return "terminalsPrictur";
      }
    }
      log.info("--------根据商品ID查询最小的图片组列表---------"); 
      List <CommodityPictureGroup> commodityPictureGroupList= remoteCommodityPictureService.listCommodityPictureGroupByCommodityId(id);
      log.info("id="+id+"--------获取所有组--------"+commodityPictureGroupList.size());
      List <CommodityPicture> listSmallCommodityPicture=new ArrayList<CommodityPicture>();
      log.info("--------获取所有组下面的最小图片--------");
      for(CommodityPictureGroup group:commodityPictureGroupList){
       CommodityPicture c= remoteCommodityPictureService.getSmallCommodityPictureByGroupId(group.getPictureGroupId());
       listSmallCommodityPicture.add(c);
      }
      HttpServletRequest request = (HttpServletRequest) ActionContext
     .getContext().get(StrutsStatics.HTTP_REQUEST);
      request.setAttribute("listSmallCommodityPicture", listSmallCommodityPicture);
      log.info("--------最小图片保存到一个集合完毕返回页面--------");  
   } catch (Exception e) {
    e.printStackTrace();
    return "error";
   }
  return "terminalsPrictur";
 }
 //获取图片后缀
 private  String getExtention(String fileName) {
         int pos = fileName.lastIndexOf(".");
         return fileName.substring(pos);
    }
  //把图片打成字符数组
 public byte[] fileToByteArray(File file) {
  ByteArrayOutputStream bStrm = null;
  InputStream is = null;
  try {
   is = new FileInputStream(file);
   int ch;
   bStrm = new ByteArrayOutputStream();
   while ((ch = is.read()) != -1) {
    bStrm.write(ch);
   }
   return bStrm.toByteArray();
  } catch (Exception e) {
   return null;
  } finally {
   if (is != null) {
    try {
     is.close();
    } catch (Exception ee) {
    }
   }
   if (bStrm != null) {
    try {
     bStrm.close();
    } catch (Exception ee) {
    }
   }
  }
 }

    //复制文件 
 private static void copy(File src, File dst) {
        try {
           InputStream in = null ;
           OutputStream out = null ;
            try {               
               in = new BufferedInputStream( new FileInputStream(src), BUFFER_SIZE);
               out = new BufferedOutputStream( new FileOutputStream(dst), BUFFER_SIZE);
                byte [] buffer = new byte [BUFFER_SIZE];
                while (in.read(buffer) > 0 ) {
                   out.write(buffer);
               }
           } finally {
                if ( null != in) {
                   in.close();
               }
                if ( null != out) {
                   out.close();
               }
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
   }

 
 public String getpicture() {
  String result="success";
  CommodityPicture cp= remoteCommodityPictureService.getCommodityPictureById(pictureId);
  inputStream=new ByteArrayInputStream(cp.getPictureData());
  return result;
 }
 //图片大小验证
 public String checkImage(File file,int i) {

  BufferedImage bi;
  try {
   bi = ImageIO.read(file);
   int height = bi.getHeight();
   int width = bi.getWidth();
   if(i==0){
    if(height>800||width>800||height<760||width<760){
     return "特大图尺寸不合法,图片尺寸大小介于760*760和800*800之间";
    }
    
   }else if(i==1){
    if(height>400||width>400||height<320||width<320){
     return "大图尺寸不合法,图片尺寸大小介于320*320和400*400之间";
    }
   }
   else if(i==2){
    if(height>128||width>128||height<118||width<118){
     return "中图尺寸不合法,图片尺寸大小介于118*118和128*128之间";
    }
   }
   else if(i==3){
    if(height>80||width>80||height<64||width<64){
     return "中图尺寸不合法,图片尺寸大小介于64*64和80*80之间";
    }
   }
   return "SUCCESS";
  } catch (IOException e) {
   e.printStackTrace();
   return "FAILE";
  }
 }
//修改商品组默认项
 public void changeDafault(){
  
  HttpServletResponse res = (HttpServletResponse) ActionContext.getContext().get(
    org.apache.struts2.StrutsStatics.HTTP_RESPONSE);
  res.setContentType("text/json;charset=utf-8");
   HttpServletRequest request = (HttpServletRequest) ActionContext
   .getContext().get(StrutsStatics.HTTP_REQUEST);
   String groupIdAndCommId=request.getParameter("groupIdAndCommId");
   String [] array=groupIdAndCommId.split("_");
  
  Integer groupId= Integer.parseInt(array[0]);
  Integer commId= Integer.parseInt(array[1]);
  
   remoteCommodityPictureService.updateGroupDeafultToFalseByCommId(commId);
   remoteCommodityPictureService.updateGroupDeafultToTrueByGroupId(groupId);
  
  res.setCharacterEncoding("UTF-8");
  try{
   res.getWriter().print("S");
  }catch (Exception e) {
   e.printStackTrace();
    try {
    res.getWriter().print("F");
   } catch (IOException e1) {
    e1.printStackTrace();
   }
  }
 } 
 
}
JSP页面

  
                    <td><s:file label ="特大图" name ="upload" id="upload1"/></td>
                   </tr>
                   <tr>                  
                    <td><s:file label ="产品大图" name ="upload" id="upload2"/></td>
                   </tr>
                   <tr>                  
                    <td><s:file label ="产品中图" name ="upload" id="upload3"/></td>
                   </tr>
                   <tr>             
                    <td><s:file label ="产品小图" name ="upload" id="upload4"/></td>
                   </tr>

struts配置

 <action name="addPicture" class="commodity-addterminals" method="addPicture">
   <result name="terminalsPrictur">/commodity/terminalsPrictur.jsp</result>
   <result name="input">/commodity/addTerminalsPrictur.jsp</result>
      <result name="error">/commodity/error.jsp</result>
  </action>
  
  
    <action name="getpicture" class="commodity-addterminals" method="getpicture">
      <result type="stream" name="success">
       <param name="contentType">image/jpeg</param>
       <param name="inputName">inputStream</param>
      </result>
     </action>

图片显示JSP页面

    <c:forEach items="${listSmallCommodityPicture}" var="picture">
                   <td>
                    <img src="getpicture.shtml?pictureId=${picture.pictureId}"/><br></br>
                    <input type="radio" name="isDefault" onclick="aaaa(${picture.pictureGroup.pictureGroupId}+'_'+${picture.pictureGroup.commoditySpec})"
                        <c:if test="${picture.pictureGroup.isDefault==true}"> checked="checked"</c:if>
                    />${picture.pictureGroup.pictureGroupName}
                   </td>
               </c:forEach>