Java Code Examples for javax.servlet.http.HttpServletRequest#getContentLength()

/**
 * 描述:获取 post 请求的 byte[] 数组
 * <pre>
 * 举例：
 * </pre>
 *
 * @param request
 * @return
 * @throws IOException
 */
public static byte[] getRequestPostBytes(HttpServletRequest request)
        throws IOException {
    int contentLength = request.getContentLength();
    if (contentLength < 0) {
        return null;
    }
    byte buffer[] = new byte[contentLength];
    for (int i = 0; i < contentLength; ) {
        int readlen = request.getInputStream().read(buffer, i,
                contentLength - i);
        if (readlen == -1) {
            break;
        }
        i += readlen;
    }
    return buffer;
}
 

/**
 * 获取 request 请求的 byte[] 数组
 *
 * @param request request
 * @return byte[]
 * @throws IOException IOException
 */
public static byte[] getRequestBytes(HttpServletRequest request) throws IOException {
	int contentLength = request.getContentLength();
	if (contentLength < 0) {
		return null;
	}
	byte[] buffer = new byte[contentLength];
	for (int i = 0; i < contentLength; ) {

		int readlen = request.getInputStream().read(buffer, i, contentLength - i);
		if (readlen == -1) {
			break;
		}
		i += readlen;
	}
	return buffer;
}
 

/**
 * retryEnabled の時だけだよ
 * @return
 */
private ContentProvider createRetryContentProvider() {
    final HttpServletRequest request = this.request;

    return new InputStreamContentProvider(
            new SequenceInputStream(new ByteArrayInputStream(this.contentBuffer.toByteArray()),
                    this.contentInputStream)) {
        @Override
        public long getLength() {
            return request.getContentLength();
        }

        @Override
        protected ByteBuffer onRead(byte[] buffer, int offset, int length) {
            if (ProxyServlet.this._isDebugEnabled) {
                ProxyServlet.this._log
                        .debug("{} proxying content to upstream: {} bytes", getRequestId(request), length);
            }
            return super.onRead(buffer, offset, length);
        }
    };
}
 

/**
 * 获取 request 请求的 byte[] 数组
 *
 * @param request request
 * @return byte[]
 * @throws IOException IOException
 */
public static byte[] getRequestBytes(HttpServletRequest request) throws IOException {
	int contentLength = request.getContentLength();
	if (contentLength < 0) {
		return null;
	}
	byte[] buffer = new byte[contentLength];
	for (int i = 0; i < contentLength; ) {
		int readlen = request.getInputStream().read(buffer, i, contentLength - i);
		if (readlen == -1) {
			break;
		}
		i += readlen;
	}
	return buffer;
}
 

String binaryReader(HttpServletRequest request) throws IOException {
    int len = request.getContentLength();
    ServletInputStream iii = request.getInputStream();
    byte[] buffer = new byte[len];
    iii.read(buffer, 0, len);
    return new String(buffer);
}
 

public boolean uploadFile( HttpServletRequest req) throws ServletException, IOException{
    setCharacterEncoding(req.getCharacterEncoding());
    setContentType(req.getContentType());
    m_totalBytes = req.getContentLength();
    if(!(m_totalBytes>maxSize))
    {
        uploadFile(req.getInputStream());
        return true;
    }
    else
    {
        return false;
    }
}
 

private TimeStampRequest readRequest(HttpServletRequest req, boolean isBase64) throws Exception {
    byte[] requestBytes = new byte[req.getContentLength()];
    ServletInputStream inputStream = req.getInputStream();
    IOUtils.read(inputStream, requestBytes);
    if (isBase64) {
        return new TimeStampRequest(Base64.decode(requestBytes));
    } else {
        return new TimeStampRequest(requestBytes);
    }
}
 

private static HttpHeaders initHeaders(HttpHeaders headers, HttpServletRequest request) {
	MediaType contentType = headers.getContentType();
	if (contentType == null) {
		String requestContentType = request.getContentType();
		if (StringUtils.hasLength(requestContentType)) {
			contentType = MediaType.parseMediaType(requestContentType);
			headers.setContentType(contentType);
		}
	}
	if (contentType != null && contentType.getCharset() == null) {
		String encoding = request.getCharacterEncoding();
		if (StringUtils.hasLength(encoding)) {
			Charset charset = Charset.forName(encoding);
			Map<String, String> params = new LinkedCaseInsensitiveMap<>();
			params.putAll(contentType.getParameters());
			params.put("charset", charset.toString());
			headers.setContentType(
					new MediaType(contentType.getType(), contentType.getSubtype(),
							params));
		}
	}
	if (headers.getContentLength() == -1) {
		int contentLength = request.getContentLength();
		if (contentLength != -1) {
			headers.setContentLength(contentLength);
		}
	}
	return headers;
}
 

/**
 * Create a new ContentCachingRequestWrapper for the given servlet request.
 * @param request the original servlet request
 */
public ContentCachingRequestWrapper(HttpServletRequest request) {
	super(request);
	int contentLength = request.getContentLength();
	this.cachedContent = new ByteArrayOutputStream(contentLength >= 0 ? contentLength : 1024);
	this.contentCacheLimit = null;
}
 

public HttpServletRequestSnapshot(HttpServletRequest request) {
    super(request);
    authType = request.getAuthType();
    characterEncoding = request.getCharacterEncoding();
    contentLength = request.getContentLength();
    contentType = request.getContentType();
    contextPath = request.getContextPath();
    cookies = request.getCookies();
    requestHeaderNames = request.getHeaderNames();
    Enumeration<String> tmp = request.getHeaderNames();
    while (tmp.hasMoreElements()) {
        String key = tmp.nextElement();
        headersMap.put(key, request.getHeaders(key));
    }
    localAddr = request.getLocalAddr();
    local = request.getLocale();
    localName = request.getLocalName();
    localPort = request.getLocalPort();
    method = request.getMethod();
    pathInfo = request.getPathInfo();
    pathTranslated = request.getPathTranslated();
    protocol = request.getProtocol();
    queryString = request.getQueryString();
    remoteAddr = request.getRemoteAddr();
    remoteHost = request.getRemoteHost();
    remotePort = request.getRemotePort();
    remoteUser = request.getRemoteUser();
    requestURI = request.getRequestURI();
    requestURL = request.getRequestURL();
    requestedSessionId = request.getRequestedSessionId();
    schema = request.getScheme();
    serverName = request.getServerName();
    serverPort = request.getServerPort();
    servletPath = request.getServletPath();
    if (request.isRequestedSessionIdValid()) {
        session = request.getSession();
    }
    principal = request.getUserPrincipal();
}
 

/**
 * Adds span label annotations based on the given HTTP servlet request to the given labels
 * builder.
 *
 * @param request       the http servlet request used to generate the span label annotations.
 * @param labelsBuilder the labels builder to add span label annotations to.
 */
public static void addRequestLabels(HttpServletRequest request, Labels.Builder labelsBuilder) {
  labelsBuilder.add("/http/method", request.getMethod());
  labelsBuilder.add("/http/url", request.getRequestURL().toString());
  if (request.getContentLength() != -1) {
    labelsBuilder.add(
        "/http/request/size", Integer.toString(request.getContentLength()));
  }
  labelsBuilder.add("/http/host", request.getServerName());
  if (request.getHeader("user-agent") != null) {
    labelsBuilder.add("/http/user_agent", request.getHeader("user-agent"));
  }
}
 

private String readBody(HttpServletRequest request) throws IOException {

		StringBuilder buffer = new StringBuilder(request.getContentLength());
		String line = null;
		BufferedReader reader = request.getReader();
		while ((line = reader.readLine()) != null) {
			buffer.append(line);
		}

		return buffer.toString();
	}
 

private String getRequestCompletedMessage(boolean includeHeaders, Duration elapsed,
        String id, HttpServletRequest httpRequest, HttpServletResponse httpResponse) {
    StringBuilder message = new StringBuilder("Request ")
            .append(id)
            .append(" completed in ")
            .append(elapsed)
            .append(": response ")
            .append(httpResponse.getStatus())
            .append(" for ")
            .append(httpRequest.getMethod())
            .append(" ")
            .append(httpRequest.getRequestURI())
            .append(" from ")
            .append(httpRequest.getRemoteAddr());

    if (!httpRequest.getParameterMap().isEmpty()) {
        message.append(", parameters: ")
                .append(Joiner.on(", ").withKeyValueSeparator("=").join(httpRequest.getParameterMap()));
    }
    if (httpRequest.getContentLength() > 0) {
        int len = httpRequest.getContentLength();
        message.append(" contentType=").append(httpRequest.getContentType())
                .append(" (length=").append(len).append(")");
    }
    if (includeHeaders) {
        Enumeration<String> headerNames = httpRequest.getHeaderNames();
        if (headerNames.hasMoreElements()) {
            message.append(", headers: ");
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                message.append(headerName).append(": ");
                if (CENSORED_HEADERS.contains(headerName)) {
                    message.append("******");
                } else {
                    message.append(httpRequest.getHeader(headerName));
                }
                if (headerNames.hasMoreElements()) {
                    message.append(", ");
                }
            }
        }
    }

    return message.toString();
}
 

protected String handleRequest(HttpServletRequest request, HttpServletResponse response, Map<String,String> metaInfo)
        throws ServiceException, IOException {

    if (logger.isMdwDebugEnabled()) {
        logger.mdwDebug(getClass().getSimpleName() + " " + request.getMethod() + ":\n   "
          + request.getRequestURI() + (request.getQueryString() == null ? "" : ("?" + request.getQueryString())));
    }

    String requestString = null;
    // DELETE can have a body in some containers
    if (!"GET".equalsIgnoreCase(request.getMethod())) {
        BufferedReader reader = request.getReader();
        StringBuffer requestBuffer = new StringBuffer(request.getContentLength() < 0 ? 0 : request.getContentLength());
        String line;
        while ((line = reader.readLine()) != null)
            requestBuffer.append(line).append('\n');

        // log request
        requestString = requestBuffer.toString();
        if (logger.isMdwDebugEnabled()) {
            logger.mdwDebug(getClass().getSimpleName() + " " + request.getMethod() + " Request:\n" + requestString);
        }
    }

    authenticate(request, metaInfo, requestString);
    if (metaInfo.containsKey(Listener.METAINFO_REQUEST_PAYLOAD)) {
        requestString = metaInfo.get(Listener.METAINFO_REQUEST_PAYLOAD);
        metaInfo.remove(Listener.METAINFO_REQUEST_PAYLOAD);
    }

    Set<String> reqHeaderKeys = new HashSet<>(metaInfo.keySet());
    String responseString = new ListenerHelper().processRequest(requestString, metaInfo);
    populateResponseHeaders(reqHeaderKeys, metaInfo, response);
    if (metaInfo.get(Listener.METAINFO_CONTENT_TYPE) == null)
        response.setContentType("application/json");
    else
        response.setContentType(metaInfo.get(Listener.METAINFO_CONTENT_TYPE));

    if (metaInfo.get(Listener.METAINFO_HTTP_STATUS_CODE) != null && !metaInfo.get(Listener.METAINFO_HTTP_STATUS_CODE).equals("0"))
        response.setStatus(Integer.parseInt(metaInfo.get(Listener.METAINFO_HTTP_STATUS_CODE)));

    if (logger.isMdwDebugEnabled()) {
        logger.mdwDebug(getClass().getSimpleName() + " " + request.getMethod() + " Response:\n" + responseString);
    }

    return responseString;
}
 

/**
 * 上传验证,并初始化文件目录
 * 
 * @param request
 */
private String validateFields(HttpServletRequest request) {
	String errorInfo = "true";
	// boolean errorFlag = true;
	// 获取内容类型
	String contentType = request.getContentType();
	int contentLength = request.getContentLength();
	// 文件保存目录路径
	savePath = request.getSession().getServletContext().getRealPath("/") + basePath + "/";
	// 文件保存目录URL
	saveUrl = request.getContextPath() + "/" + basePath + "/";
	File uploadDir = new File(savePath);
	if (contentType == null || !contentType.startsWith("multipart")) {
		// TODO
		org.jeecgframework.core.util.LogUtil.info("请求不包含multipart/form-data流");
		errorInfo = "请求不包含multipart/form-data流";
	} else if (maxSize < contentLength) {
		// TODO
		org.jeecgframework.core.util.LogUtil.info("上传文件大小超出文件最大大小");
		errorInfo = "上传文件大小超出文件最大大小[" + maxSize + "]";
	} else if (!ServletFileUpload.isMultipartContent(request)) {
		// TODO
		errorInfo = "请选择文件";
	} else if (!uploadDir.isDirectory()) {// 检查目录
		// TODO
		errorInfo = "上传目录[" + savePath + "]不存在";
	} else if (!uploadDir.canWrite()) {
		// TODO
		errorInfo = "上传目录[" + savePath + "]没有写权限";
	} else if (!extMap.containsKey(dirName)) {
		// TODO
		errorInfo = "目录名不正确";
	} else {
		// .../basePath/dirName/
		// 创建文件夹
		savePath += dirName + "/";
		saveUrl += dirName + "/";
		File saveDirFile = new File(savePath);
		if (!saveDirFile.exists()) {
			saveDirFile.mkdirs();
		}
		// .../basePath/dirName/yyyyMMdd/
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		String ymd = sdf.format(new Date());
		savePath += ymd + "/";
		saveUrl += ymd + "/";
		File dirFile = new File(savePath);
		if (!dirFile.exists()) {
			dirFile.mkdirs();
		}

		// 获取上传临时路径
		tempPath = request.getSession().getServletContext().getRealPath("/") + tempPath + "/";
		File file = new File(tempPath);
		if (!file.exists()) {
			file.mkdirs();
		}
	}

	return errorInfo;
}
 

@RequestMapping(value = "tsa", method = RequestMethod.POST)
public void tsa(HttpServletRequest req, HttpServletResponse resp) {
    String remoteIp = req.getRemoteAddr();
    try {
        if (!TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE.equalsIgnoreCase(req.getContentType())) {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "content type should be " + TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE);
            return;
        }
        if (!TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE.equalsIgnoreCase(req.getContentType())) {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "content type should be " + TsaTranserConstant.TIMESTAMP_QUERY_CONTENT_TYPE);
            return;
        }
        if (littleTsaConfig.isUsernameEnabled()) {
            if (!littleTsaConfig.getTsaUsername().equals(req.getHeader("username")) || !littleTsaConfig.getTsaPassword().equals(req.getHeader("password"))) {
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "username and password must match");
                return;
            }
        }
        if (req.getContentLength() == 0) {
            LOG.error("timestamp request is empty");
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "timestamp request is empty");
            return;
        }
        boolean isBase64 = TsaTranserConstant.isBase64(req.getHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER));
        TimeStampRequest timeStampRequest = readRequest(req, isBase64);

        LOG.debug("TS Request received from {}", remoteIp);
        TimeStampResponse stampResponse = timeStampService.timestamp(timeStampRequest);
        if (stampResponse == null) {
            LOG.warn("TS Request received from {} is not acceptable", remoteIp);
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
            return;
        }
        if (stampResponse.getTimeStampToken() == null) {
            LOG.warn("TS Request received from {} is not acceptable", remoteIp);
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
            return;
        }
        byte[] response = stampResponse.getEncoded();
        if (isBase64) {
            resp.setHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER, TsaTranserConstant.TRANSFER_ENCODING_BASE64);
            response = Base64.encode(response);
            LOG.debug("Responding to {} is in base64", remoteIp);
        } else {
            resp.setHeader(TsaTranserConstant.TRANSFER_ENCODING_HEADER, TsaTranserConstant.TRANSFER_ENCODING_BINARY);
            LOG.debug("Responding to %s is in binary mode", remoteIp);
        }

        resp.setStatus(HttpServletResponse.SC_OK);
        resp.setContentType(TsaTranserConstant.TIMESTAMP_REPLY_CONTENT_TYPE);
        resp.setContentLength(response.length);
        ServletOutputStream outputStream = resp.getOutputStream();
        outputStream.write(response);
        outputStream.close();
    } catch (Exception e) {
        LOG.warn("TS Request received from {} is not acceptable", remoteIp);
        try {
            resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Could not generate timestamp response");
        } catch (IOException ex) {
            LOG.error("error,{}", ex);
        }
    }
}
 

@Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp) {
    setDefaultHeader(resp);
    UploadResponse uploadResponse;

    String uri = req.getRequestURI();
    // First, call split with no limit parameter.
    String[] uriComponents = uri.split("/");

    if (true) {
      String requestType = uriComponents[REQUEST_TYPE_INDEX];
      if (DEBUG) {
        LOG.info("######### GOT IN URI");
        LOG.info(requestType);
      }

      long project_Id = -1;
      String user_Id = "-1";
      if (requestType.equalsIgnoreCase("apps")) {
        project_Id = Long.parseLong(uriComponents[GALLERY_OR_USER_ID_INDEX]);
      } else if (requestType.equalsIgnoreCase("user")) {
        //the code below doesn't check if user_Id is the id of current user
        //user_Id = uriComponents[GALLERY_OR_USER_ID_INDEX];
        user_Id = userInfoProvider.getUserId();
      }
      InputStream uploadedStream;
      try {
        if(req.getContentLength() < MAX_IMAGE_FILE_SIZE){
          uploadedStream = getRequestStream(req, ServerLayout.UPLOAD_FILE_FORM_ELEMENT);

          // Converts the input stream to byte array
          byte[] buffer = new byte[8000];
          int bytesRead = 0;
          ByteArrayOutputStream bao = new ByteArrayOutputStream();
          while ((bytesRead = uploadedStream.read(buffer)) != -1) {
            bao.write(buffer, 0, bytesRead);
          }
          // Set up the cloud file (options)
          String key = "";
          GallerySettings settings = galleryService.loadGallerySettings();
          if (requestType.equalsIgnoreCase("apps")) {
            key = settings.getProjectImageKey(project_Id);
          } else if (requestType.equalsIgnoreCase("user")) {
            key =  settings.getUserImageKey(user_Id);
          }

          // setup cloud
          GcsService gcsService = GcsServiceFactory.createGcsService();
          GcsFilename filename = new GcsFilename(settings.getBucket(), key);
          GcsFileOptions options = new GcsFileOptions.Builder().mimeType("image/jpeg")
                  .acl("public-read").cacheControl("no-cache").build();
          GcsOutputChannel writeChannel = gcsService.createOrReplace(filename, options);
          writeChannel.write(ByteBuffer.wrap(bao.toByteArray()));

          // Now finalize
          writeChannel.close();

          uploadResponse = new UploadResponse(UploadResponse.Status.SUCCESS);
        }else{
          /*file exceeds size of MAX_IMAGE_FILE_SIZE*/
          uploadResponse = new UploadResponse(UploadResponse.Status.FILE_TOO_LARGE);
        }

        // Now, get the PrintWriter for the servlet response and print the UploadResponse.
        // On the client side, in the onSubmitComplete method in ode/client/utils/Uploader.java, the
        // UploadResponse value will be retrieved as a String via the
        // FormSubmitCompleteEvent.getResults() method.
        PrintWriter out = resp.getWriter();
        out.print(uploadResponse.formatAsHtml());

      } catch (Exception e) {
        throw CrashReport.createAndLogError(LOG, req, null, e);
      }
      // Set http response information
      resp.setStatus(HttpServletResponse.SC_OK);
    }

    // Now, get the PrintWriter for the servlet response and print the UploadResponse.
    // On the client side, in the onSubmitComplete method in ode/client/utils/Uploader.java, the
    // UploadResponse value will be retrieved as a String via the
    // FormSubmitCompleteEvent.getResults() method.
//    PrintWriter out = resp.getWriter();
//    out.print(uploadResponse.formatAsHtml());

    // Set http response information
    resp.setStatus(HttpServletResponse.SC_OK);
  }
 

/**
 * 上传验证,并初始化文件目录
 * 
 * @param request
 */
private String validateFields(HttpServletRequest request) {
	String errorInfo = "true";
	// boolean errorFlag = true;
	// 获取内容类型
	String contentType = request.getContentType();
	int contentLength = request.getContentLength();
	// 文件保存目录路径
	savePath = request.getSession().getServletContext().getRealPath("/") + basePath + "/";
	// 文件保存目录URL
	saveUrl = request.getContextPath() + "/" + basePath + "/";
	File uploadDir = new File(savePath);
	if (contentType == null || !contentType.startsWith("multipart")) {
		// TODO
		org.jeecgframework.core.util.LogUtil.info("请求不包含multipart/form-data流");
		errorInfo = "请求不包含multipart/form-data流";
	} else if (maxSize < contentLength) {
		// TODO
		org.jeecgframework.core.util.LogUtil.info("上传文件大小超出文件最大大小");
		errorInfo = "上传文件大小超出文件最大大小[" + maxSize + "]";
	} else if (!ServletFileUpload.isMultipartContent(request)) {
		// TODO
		errorInfo = "请选择文件";
	} else if (!uploadDir.isDirectory()) {// 检查目录
		// TODO
		errorInfo = "上传目录[" + savePath + "]不存在";
	} else if (!uploadDir.canWrite()) {
		// TODO
		errorInfo = "上传目录[" + savePath + "]没有写权限";
	} else if (!extMap.containsKey(dirName)) {
		// TODO
		errorInfo = "目录名不正确";
	} else {
		// .../basePath/dirName/
		// 创建文件夹
		savePath += dirName + "/";
		saveUrl += dirName + "/";
		File saveDirFile = new File(savePath);
		if (!saveDirFile.exists()) {
			saveDirFile.mkdirs();
		}
		// .../basePath/dirName/yyyyMMdd/
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		String ymd = sdf.format(new Date());
		savePath += ymd + "/";
		saveUrl += ymd + "/";
		File dirFile = new File(savePath);
		if (!dirFile.exists()) {
			dirFile.mkdirs();
		}

		// 获取上传临时路径
		tempPath = request.getSession().getServletContext().getRealPath("/") + tempPath + "/";
		File file = new File(tempPath);
		if (!file.exists()) {
			file.mkdirs();
		}
	}

	return errorInfo;
}
 

/**
 * parse HttpServletRequest.
 *
 * @param request
 * @throws IOException
 */
public ParsedHttpRequest(final HttpServletRequest request) throws IOException {
  this.pathInfo = request.getPathInfo() != null ? request.getPathInfo() : "";
  this.method = request.getMethod() != null ? request.getMethod() : "";
  this.queryString = request.getQueryString() != null ? request.getQueryString() : "";
  this.requestUri = request.getRequestURI() != null ? request.getRequestURI() : "";
  this.requestUrl = request.getRequestURL().toString();

  for (final Enumeration en = request.getHeaderNames(); en.hasMoreElements();) {
    final String headerName = en.nextElement().toString();
    this.headers.put(headerName, request.getHeader(headerName));
  }

  final int len = request.getContentLength();
  if (len > 0) {
    this.inputStream = new byte[len];
    request.getInputStream().read(this.inputStream);
  } else {
    this.inputStream = new byte[0];
  }

  final String[] parts = this.requestUri.split("/");
  this.targetSpecification = parts.length > 1 ? parts[1] : null;
  this.version = parts.length > 2 ? parts[2] : null;
  this.targetEntity = parts.length > 3 ? parts[3] : null;

  if (!this.queryString.isEmpty()) {
    final String[] pairs = this.queryString.split("&");
    for (final String pair : pairs) {
      final int idx = pair.indexOf("=");
      if (idx != -1) {
        final String rKey = pair.substring(0, idx);
        final String rValue = pair.substring(idx + 1);
        final String key = URLDecoder.decode(rKey, "UTF-8");
        final String value = URLDecoder.decode(rValue, "UTF-8");
        List<String> valuesList = this.queryPairs.get(key.toLowerCase());
        if (valuesList == null) {
          valuesList = new ArrayList<>(1);
          this.queryPairs.put(key, valuesList);
        }
        valuesList.add(value);
      }
    }
  }
}
 

/**
 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
 *      response)
 */
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	InputStream is = null;
	OutputStream os = null;
	try {
		Part part = null;
		try {
			part = request.getPart("file");
		} catch (Exception e) {
		}
		String contentType = null;
		int contentLength = -1;
		if (part == null) {
			is = request.getInputStream();
			contentType = request.getContentType();
			contentLength = request.getContentLength();
		} else {
			is = part.getInputStream();
			contentType = part.getContentType();
			contentLength = (int) part.getSize();
		}
		response.addHeader("Access-Control-Allow-Origin", "*");
		if (contentType != null) {
			response.setContentType(contentType);
		}
		if (contentLength > 0) {
			response.setContentLength(contentLength);
		}
		os = response.getOutputStream();
		byte data[] = new byte[4096];
		int len = 0;
		while ((len = is.read(data, 0, data.length)) > 0) {
			os.write(data, 0, len);
		}
		os.flush();
	} finally {
		if (is != null) {
			is.close();
		}
		if (os != null) {
			os.close();
		}
	}
}