SpringBoot图片上传(三)——调用文件上传项目的方法(同时启动两个项目)

简单说明：图片上传有一个专门的工程A，提供了图片的上传和下载预览，工程B涉及到图片上传以及回显，都是调用的工程A的方法，言外之意就是要同时启动两个项目。

代码：

//工程B的html代码
<div class="col-md-12">
    <label class="control-label flex" style="margin-top: 10px;">
        上传图标<span class="star align-items">*</span>
    </label>
    <input type="file" name="file" value="上传图标" id="fileupload" th:onchange="|fileUpload()|" style="display:none"/>
    <img src="/xxxxxx/img/shangchuan.png"  alt="" th:onclick="|uploadfile()|" id="imageId" style="margin-top: 10px;"/>
    <input type="hidden" id="serviceIcon" name="serviceIcon" class="form-control"/>
</div>

//工程B的js代码
<script type="text/javascript">
　　function uploadfile(){
   　　 $("#fileupload").trigger("click");
　　}
//文件上传
function fileUpload(file){
        var myform = new FormData();
        myform.append('file', $("#fileupload")[0].files[0]);
        var max_size = 512;// 300k
        var tmpFile = $("#fileupload").val();
        var imgtype  = tmpFile.toLowerCase().split('.');
        if ((imgtype[1]) != "jpg") {
            layer.msg("图片只支持jpg格式");
            tmpFile.value = "";
            return false;
        } else {
                $.ajax({
                    type:"POST",
                    url: rootPath + "/serv/service/updatefile",
                    data:myform,
                    cache: false,
                    contentType: false,
                    processData: false,
                    dataType: "json",//返回的数据格式
                    async: false,
                    success: function (data) {
                        if(data==="1" ){
                            layer.msg("上传失败，图片内存过大");
                        }else if(data=="2"){
                            layer.msg("上传失败，图片内存过大");
                        }else{
                            var path="/oh-manager/"+data;
　　　　　　　　　　　　　　　　//IP是文件上传项目A在服务器的地址 upload是controller的注解 showPic是方法
                            var imgPlanIcon ='http://10.131.103.220:8590/upload/showPic?ppath=' + data;
                            $('#imageId').attr('src', imgPlanIcon);
                            $('#serviceIcon').val(data);
                        }
                    },
                    error: function (jqXHR, textStatus, errorThrown) {

                    }
                });
        }
        return false;
    }
</script>

//工程B的后台java代码
@RequestMapping(value="/updatefile")
public @ResponseBody String updatefile(@RequestParam("file") MultipartFile file,
                                       HttpServletRequest request) {
    // 创建httpclient对象
    CloseableHttpClient httpClient = HttpClients.createDefault();
    // 创建post方式请求对象 请求地址是工程A的文件上传方法upimgs
    HttpPost httpPost = new HttpPost("http://10.131.103.220:8590/upload/upimgs");
    String fileName = file.getOriginalFilename();
    String filePath = "D:/image/temp";
    try {
        MultipartEntityBuilder builder = MultipartEntityBuilder.create();
        builder.addBinaryBody("file", file.getInputStream(), ContentType.MULTIPART_FORM_DATA, fileName);// 文件流
        builder.addTextBody("filename", fileName);// 类似浏览器表单提交，对应input的name和value
        HttpEntity entity = builder.build();
        httpPost.setEntity(entity);
        CloseableHttpResponse response = httpClient.execute(httpPost);
        // 获取响应对象
        HttpEntity resEntity = response.getEntity();
        if (resEntity != null) {
            // 打印响应内容
            String aa=EntityUtils.toString(resEntity, Charset.forName("UTF-8"));
            JSONObject data2 = JSONObject.fromObject(aa);
            fileName=data2.getString("title");
        }
        // 销毁
        EntityUtils.consume(resEntity);
        File targetFile = new File(filePath);
        if(!targetFile.exists()){
            targetFile.mkdirs();
        }
        File fileRoute = new File(filePath+"/"+fileName);
        BufferedImage sourceImg =ImageIO.read(fileRoute);
        Long size = file.getSize() / 1024; // 图片大小
        int wid=sourceImg.getWidth(); // 源图宽度
        int hei=sourceImg.getHeight(); // 源图高度
        if(size>512){
            fileName="1";
        }
        if(wid>60 || hei>60){
            fileName="2";
        }
    } catch (Exception e) {
        // TODO: handle exception
    }
    //返回json
    return fileName;//返回js的成功回调函数
} 

//工程A的上传方法upload/upimgs
@RequestMapping(path="/upimgs", method=RequestMethod.POST,produces = "application/json;charset=utf-8")
    @ResponseBody
    //@CrossOrigin("*") //可跨域访问
//  public String uploadImgs(HttpServletRequest request) throws IllegalStateException, IOException {  
    public FileSaveResult uploadImgs(HttpServletRequest request) throws IllegalStateException, IOException {
//     String reResult="";
       FileSaveResult reResult = null;
      try {
         reResult = FileSaveUtil.uploadImg(request);
      } catch (IllegalStateException e) {
         logger.error(e,e);
         e.printStackTrace();
      } catch (IOException e) {
         logger.error(e,e);
         e.printStackTrace();
      }
       return reResult;
    }  
//FileSaveUil工具类里的图片上传方法
public static FileSaveResult uploadImg(HttpServletRequest request) throws IllegalStateException, IOException {
      
      logger.info("文件正在被上传，请稍等...");
      
      boolean flag = false;
//    Map<String, Object> result = new HashMap<String, Object>();
      FileSaveResult result = null;

      String prePath = request.getParameter("prePath");
   /* if (StringUtil.getNullStr(prePath).equals("") || StringUtil.getNullStr(prePath).equals("null")) {
//       result.put("state", "false");
//       result.put("msg", "图片存放前置路径不可为空！");
//       JSONObject jo = JSONObject.fromObject(result);
//       return jo.toString();
         result = new FileSaveResult(
               FileSaveResultConstant.STATE_UPLOAD_FILE_PREPATH_EMPTY_CODE,
               FileSaveResultConstant.STATE_UPLOAD_FILE_PREPATH_EMPTY_CODE_MSG);
         return result;
      }*/
      // 创建一个通用的多部分解析器
      String filePath = FileuploadEnv.getFileImgPath();
      String path = "";
      String suffix = "";
      // 当前上传文件的文件名称
      String myFileName = "";
      // 图片大小
      long size = 0;
      // 重命名上传后的文件名
      String fileName = "";
      
      float rate= 1.0f;
      // 判断 request 是否有文件上传,即多部分请求
      if (request instanceof MultipartHttpServletRequest) {  //multipartResolver.isMultipart(request)
         // 转换成多部分request
         MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request;
         // 取得request中的所有文件名
         Iterator<String> iter = multiRequest.getFileNames();
         while (iter.hasNext()) {
            // 取得上传文件
            MultipartFile file = multiRequest.getFile(iter.next());
            if (file != null && !file.isEmpty()) {
               // 取得当前上传文件的文件名称
               myFileName = file.getOriginalFilename();
               
               // 获取文件后缀
               suffix = FileType.getSuffixByFilename(myFileName);
               
               // 图片扩展名判定
               boolean judgeResult = FileExtensionUtil.fileExtensionJudge(suffix);
               if (!judgeResult) {
                  logger.info("上传的图片资源格式不正确，不可上传。图片格式：" + suffix + "， 格式限制：" + FileExtensionUtil.IMG_SUFFIX);
                  result = new FileSaveResult(
                        FileSaveResultConstant.STATE_UPLOAD_FILE_EXTENSION_NOT_ALLOWD_CODE, 
                        FileSaveResultConstant.STATE_UPLOAD_FILE_EXTENSION_NOT_ALLOWD_CODE_MSG);
                  return result;
               }
               
               // 获取图片大小
               /*size = file.getSize();
               if (size > 5217880) { // 5M*1024*1024
                  result.put("state", "false");
                  result.put("msg", "图片文件过大,请压缩至5M以下！");
                  JSONObject jo = JSONObject.fromObject(result);
                  return jo.toString();
               }*/
               size = file.getSize();
               if (size > 1043576) { // 1M*1024*1024
                  float s1=size/1043576.0f;
                  rate=1.0f/s1;
               }
               // 如果名称不为“”,说明该文件存在，否则说明该文件不存在
               if (myFileName.trim() != "") {
                  // 重命名上传后的文件名
                  fileName = UuidUtil.get32Uuid() + suffix;
                  // 从配置文件获得上传路径
                  String parentPath = filePath + "/";
                  path = parentPath + "/" + fileName;
                  File parentFile = new File(parentPath);
                  File localFile = null;
                  if (!parentFile.exists()) {       // 如果父目录不存在，那么创建父目录
                     parentFile.mkdirs();
                  }
                  localFile = new File(path);
                  file.transferTo(localFile);
                  
                  // 压缩图片
                  CompressPic.reduceImg(path, localFile, 0, 0, rate, suffix);
                  
                  flag = true;
               } else {
//                result.put("state", "false");
//                result.put("msg", "文件为空！");
//                JSONObject jo = JSONObject.fromObject(result);
//                return jo.toString();
                  
                  result = new FileSaveResult(
                        FileSaveResultConstant.STATE_UPLOAD_FILE_EMPTY_CODE, 
                        FileSaveResultConstant.STATE_UPLOAD_FILE_EMPTY_CODE_MSG);
                  return result;
               }
            }
         }
         if (flag) {
//          result.put("state", "SUCCESS");
//          result.put("msg", "操作成功！");
//          result.put("url", prePath + "/" + fileName); // 文件保存路径
//          result.put("original", myFileName);// 取得当前上传文件的文件名称
//          result.put("size", size);
//          result.put("type", suffix); // 文件后缀，如.jpg
//          result.put("title", fileName); // 保存后的文件名称
//          JSONObject jo = JSONObject.fromObject(result);
//          return jo.toString();
            
            result = new FileSaveResult(
                  FileSaveResultConstant.STATE_UPLOAD_SUCCESS_CODE, 
                  FileSaveResultConstant.STATE_UPLOAD_SUCCESS_CODE_MSG, prePath + "/" + fileName, myFileName, size, suffix, fileName);
            logger.info("图片上传成功，url：" + result.getUrl());
            return result;
            
         }else{
//          result.put("state", "false");
//          result.put("msg", "上传失败！");
//          JSONObject jo = JSONObject.fromObject(result);
//          return jo.toString();
            
            result = new FileSaveResult(
                  FileSaveResultConstant.STATE_UPLOAD_FAILED_CODE, 
                  FileSaveResultConstant.STATE_UPLOAD_FAILED_CODE_MSG);
            return result;
         }
      }else{
//       result.put("state", "false");
//       result.put("msg", "上传失败-MultipartFile类型有误！");
//       JSONObject jo = JSONObject.fromObject(result);
//       return jo.toString();
         
         result = new FileSaveResult(
               FileSaveResultConstant.STATE_UPLOAD_FILE_REQUEST_ERROR_CODE, 
               FileSaveResultConstant.STATE_UPLOAD_FILE_REQUEST_ERROR_CODE_MSG);
         return result;
      }
   }

//工程A的下载回显方法upload/showPic
@RequestMapping(path="/showPic", method=RequestMethod.GET,produces = "application/json;charset=utf-8")
public void showPic(String ppath, HttpServletResponse response) {
	FileInputStream hFile = null;
	if (!ppath.equals("") && !ppath.equals("/")) {
		try {
			// 去除路径中的回溯 ../
			ppath = ppath.replace("../", "");
			// 拼接图片资源路径
			String prePath = FileuploadEnv.getFileImgPath();
			String imgFileUrl = prePath + "/" + ppath;
			System.out.println("imgFileUrl 完整路径：" + imgFileUrl);
			// 打开文件
			File file = new File(imgFileUrl);
			// 验证打开的文件是否是在 prePath 目录下，若不是，不做任何处理
			String openedFileAbsolutPath = file.getAbsolutePath();
			logger.info("打开的文件绝对路径：" + openedFileAbsolutPath);
			if (!openedFileAbsolutPath.contains(openedFileAbsolutPath)) {
				logger.info("访问的图片资源不在指定目录之下，不可返回。打开的文件绝对地址：" + openedFileAbsolutPath);
				return;
			} else {
				logger.info("访问的图片资源在指定目录之下，可以返回。");
			}
			// 图片扩展名判定
			String suffix = FileType.getSuffixByFilename(openedFileAbsolutPath);
			boolean judgeResult = FileExtensionUtil.fileExtensionJudge(suffix);
			if (!judgeResult) {
				logger.info("访问的图片资源格式不正确，不可返回。图片格式：" + suffix + "， 格式限制：" + FileExtensionUtil.IMG_SUFFIX);
				return;
			}
				
//			hFile = new FileInputStream(imgFileUrl); // 以byte流的方式打开文件 d:1.gif
			hFile = new FileInputStream(file); // 以byte流的方式打开文件 d:1.gif
				
			int i = hFile.available(); // 得到文件大小
			byte data[] = new byte[i];
			hFile.read(data); // 读数据
			response.setContentType("image/*"); // 设置返回的文件类型
			OutputStream toClient = response.getOutputStream(); // 得到向客户端输出二进制数据的对象
			toClient.write(data); // 输出数据
			toClient.flush();
			toClient.close();
			hFile.close();
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				if (hFile != null) {
					hFile.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	} else {
		return;
	}
}　　

 犯的错误总结：请求工程A的upimgs或者showPic方法的时候，地址一定要加上 http://Ip地址/要访问的Controller/要访问的方法

 　　　　  即使工程A是在本地，也需要地址也是http://本机IP/要访问的Controller/要访问的方法(相对路径)   一定不要加上什么E盘工作空间工程名称，这样的话就访问不到，直接就是ip地址+controller+方法，加E盘/·····这是绝对路径

　　　　　因为是工程B调用工程A的方法，所以要同时运行两个项目。

　　　　　http://10.131.103.220:8590/upload/showPic或者upimgs    upload是工程A的@Controller@RequestMapping("/upload")注解里的值

进入页面需要回显图片的时候，就把数据库中查到的图片名字传递到前台页面，在前台中加入js：

<script type="text/javascript" th:inline="javascript" xmlns:th="http://www.w3.org/1999/xhtml">
    //接收前台传递过来的图片名字
　　 var serviceIcon = [[${serviceIcon}]];
    if (CommnUtil.notNull(serviceIcon)) {
        var imgname = serviceIcon.split("/");
        var imgPlanIcon = 'http://10.131.103.220:8590/upload/showPic?ppath=icon/' + imgname[imgname.length - 1];
        $("#imageId").attr('src', imgPlanIcon);
        $('#serviceIcon').val(imgname[imgname.length - 1]);
    }
</script>