java类org.springframework.web.bind.annotation.RequestPart的实例源码

@ApiOperation(value = "save docker connection to DB", notes = "", response = Void.class, tags={ "Connections", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "OK", response = Void.class),
    @ApiResponse(code = 201, message = "successfully created", response = Void.class) })
@RequestMapping(value = "/connections",
        consumes = {"multipart/form-data"},
        method = RequestMethod.POST)
ResponseEntity<Void> connectionPost(@ApiParam(value = "", required = true) @RequestPart(value = "name", required = true) String name, @ApiParam(value = "", required = true) @RequestPart(value = "address", required = true) String address, @ApiParam(value = "", required = true) @RequestPart(value = "dockerTLSVerify", required = false) String dockerTLSVerify, @ApiParam(value = "") @RequestPart(value = "dockerConfig", required = false) MultipartFile dockerConfig, @ApiParam(value = "") @RequestPart(value = "file", required = false) MultipartFile upfile);

@PostMapping("/mixed")
public @ResponseBody FileInfo uploadMixed(@RequestPart("myJson") String json, 
        @RequestPart("myFile") MultipartFile file) throws Exception {
    Message message = mapper.readValue(json, Message.class);
    String text = message.getText();
    return upload(file, text);
}

/**
 * Supports the following:
 * <ul>
 * <li>@RequestParam-annotated method arguments.
 * This excludes {@link Map} params where the annotation doesn't
 * specify a name.  See {@link RequestParamMapMethodArgumentResolver}
 * instead for such params.
 * <li>Arguments of type {@link MultipartFile}
 * unless annotated with @{@link RequestPart}.
 * <li>Arguments of type {@code javax.servlet.http.Part}
 * unless annotated with @{@link RequestPart}.
 * <li>In default resolution mode, simple type arguments
 * even if not with @{@link RequestParam}.
 * </ul>
 */
@Override
public boolean supportsParameter(MethodParameter parameter) {
    Class<?> paramType = parameter.getParameterType();
    if (parameter.hasParameterAnnotation(RequestParam.class)) {
        if (Map.class.isAssignableFrom(paramType)) {
            String paramName = parameter.getParameterAnnotation(RequestParam.class).value();
            return StringUtils.hasText(paramName);
        }
        else {
            return true;
        }
    }
    else {
        if (parameter.hasParameterAnnotation(RequestPart.class)) {
            return false;
        }
        else if (MultipartFile.class.equals(paramType) || "javax.servlet.http.Part".equals(paramType.getName())) {
            return true;
        }
        else if (this.useDefaultResolution) {
            return BeanUtils.isSimpleProperty(paramType);
        }
        else {
            return false;
        }
    }
}

/**
 * Upload zipped cmd log with multipart
 *
 * @param cmdId cmd id with text/plain
 * @param file zipped cmd log with application/zip
 */
@PostMapping(path = "/log/upload")
public void uploadFullLog(@RequestPart String cmdId, @RequestPart MultipartFile file) {
    if (!Objects.equals(file.getContentType(), "application/zip")) {
        throw new IllegalParameterException("Illegal zipped log file format");
    }
    cmdService.saveLog(cmdId, file);
}

@RequestMapping(value = "/post/multiPart", method = RequestMethod.POST)
@ResponseBody
public String saveAuto(
    @RequestPart(value = "json") JsonPojo pojo,
    @RequestParam(value = "some-random") String random,
    @RequestParam(value = "data", required = false) List<MultipartFile> files) {
  System.out.println(random);
  System.out.println(pojo.getJson());
  for (MultipartFile file : files) {
    System.out.println(file.getOriginalFilename());
  }
  return "success";
}

@RequestMapping(path = "/uploadArray/{folder}", method = POST)
public HttpEntity<List<UploadInfo>> uploadArray(@PathVariable String folder, @RequestPart MultipartFile[] files, @RequestPart UploadMetadata metadata) {
    List<UploadInfo> response = new ArrayList<>();
    for (MultipartFile file : files) {
        response.add(new UploadInfo(i++, file.getSize(), folder + "/" + file.getOriginalFilename()));
    }
    return ResponseEntity.ok(response);
}

@ResponseStatus(HttpStatus.CREATED)
@RequestMapping(value = "/{id:\\d+}/import", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public void importGeojson(@PathVariable long id,
                          @RequestPart("file") MultipartFile file) throws IOException {
    if (file.isEmpty()) {
        throw new IllegalArgumentException("Empty upload");
    }

    huntingClubAreaImportFeature.importGeojson(id,
            toFeatureCollection(file.getInputStream(), file.getOriginalFilename()));
}

private String getPartName(MethodParameter methodParam) {
    RequestPart requestPart = methodParam.getParameterAnnotation(RequestPart.class);
    String partName = (requestPart != null ? requestPart.name() : "");
    if (partName.length() == 0) {
        partName = methodParam.getParameterName();
        if (partName == null) {
            throw new IllegalArgumentException("Request part name for argument type [" +
                    methodParam.getNestedParameterType().getName() +
                    "] not specified, and parameter name information not found in class file either.");
        }
    }
    return partName;
}

@RequestMapping(value = "/test", method = POST, consumes = {"multipart/mixed", "multipart/form-data"})
public ResponseEntity<Object> create(@RequestPart(name = "json-data") TestData testData,
        @RequestPart("file-data") Optional<MultipartFile> file,
        @RequestPart(name = "empty-data", required = false) TestData emptyData,
        @RequestPart(name = "iso-8859-1-data") byte[] iso88591Data) {

    Assert.assertArrayEquals(new byte[]{(byte) 0xC4}, iso88591Data);

    String url = "http://localhost:8080/test/" + testData.getName() + "/" + file.get().getOriginalFilename();
    HttpHeaders headers = new HttpHeaders();
    headers.setLocation(URI.create(url));
    return new ResponseEntity<Object>(headers, HttpStatus.CREATED);
}

/**
 * Supports the following:
 * <ul>
 * <li>@RequestParam-annotated method arguments.
 * This excludes {@link Map} params where the annotation doesn't
 * specify a name.  See {@link RequestParamMapMethodArgumentResolver}
 * instead for such params.
 * <li>Arguments of type {@link MultipartFile}
 * unless annotated with @{@link RequestPart}.
 * <li>Arguments of type {@code javax.servlet.http.Part}
 * unless annotated with @{@link RequestPart}.
 * <li>In default resolution mode, simple type arguments
 * even if not with @{@link RequestParam}.
 * </ul>
 */
@Override
public boolean supportsParameter(MethodParameter parameter) {
    Class<?> paramType = parameter.getParameterType();
    if (parameter.hasParameterAnnotation(RequestParam.class)) {
        if (Map.class.isAssignableFrom(paramType)) {
            String paramName = parameter.getParameterAnnotation(RequestParam.class).name();
            return StringUtils.hasText(paramName);
        }
        else {
            return true;
        }
    }
    else {
        if (parameter.hasParameterAnnotation(RequestPart.class)) {
            return false;
        }
        else if (MultipartFile.class == paramType || "javax.servlet.http.Part".equals(paramType.getName())) {
            return true;
        }
        else if (this.useDefaultResolution) {
            return BeanUtils.isSimpleProperty(paramType);
        }
        else {
            return false;
        }
    }
}