public void testSheets() throws Exception {
    OPCPackage pkg = OPCPackage.open(_ssTests.openResourceAsStream("SampleSS.xlsx"));

    XSSFReader r = new XSSFReader(pkg);
    byte[] data = new byte[4096];

    // By r:id
    assertNotNull(r.getSheet("rId2"));
    int read = IOUtils.readFully(r.getSheet("rId2"), data);
    assertEquals(974, read);

    // All
    Iterator<InputStream> it = r.getSheetsData();

    int count = 0;
    while (it.hasNext()) {
      count++;
      InputStream inp = it.next();
      assertNotNull(inp);
      read = IOUtils.readFully(inp, data);
      inp.close();

      assertTrue(read > 400);
      assertTrue(read < 1500);
    }
    assertEquals(3, count);
  }
Example #2
0
  public byte[] getContent() {
    // TODO Vishwas Fix error handling
    try {
      if (this.inputStream == null) {
        final FileInputStream fileInputStream = new FileInputStream(this.file);
        return IOUtils.toByteArray(fileInputStream);
      }

      return IOUtils.toByteArray(this.inputStream);
    } catch (final IOException e) {
      return null;
    }
  }
  private NPOIFSFileSystem(FileChannel channel, boolean closeChannelOnError) throws IOException {
    this(false);

    try {
      // Get the header
      ByteBuffer headerBuffer = ByteBuffer.allocate(POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
      IOUtils.readFully(channel, headerBuffer);

      // Have the header processed
      _header = new HeaderBlock(headerBuffer);

      // Now process the various entries
      _data = new FileBackedDataSource(channel);
      readCoreContents();
    } catch (IOException e) {
      if (closeChannelOnError) {
        channel.close();
      }
      throw e;
    } catch (RuntimeException e) {
      // Comes from Iterators etc.
      // TODO Decide if we can handle these better whilst
      //  still sticking to the iterator contract
      if (closeChannelOnError) {
        channel.close();
      }
      throw e;
    }
  }
  public static void extractGM(String pathToGMData) {
    String directoryPath = DirectorySettings.getCacheDirectory().getAbsolutePath();
    try {
      File data = new File(pathToGMData);
      ZipFile zipData = new ZipFile(data.getAbsolutePath());
      Enumeration entries = zipData.entries();
      while (entries.hasMoreElements()) {
        ZipEntry entry = (ZipEntry) entries.nextElement();
        if (entry.isDirectory()) {
          (new File(directoryPath + File.separator + entry.getName())).mkdirs();
          continue;
        }

        IOUtils.copy(
            zipData.getInputStream(entry),
            new FileOutputStream(directoryPath + File.separator + entry.getName()));
      }
      zipData.close();
      FileWriter fstream =
          new FileWriter(
              DirectorySettings.getGeneManiaDirectory()
                  + File.separator
                  + DirectorySettings.GENEMANIA_CHECK_FILE);
      BufferedWriter out = new BufferedWriter(fstream);
      out.write("This file indicates that the GeneMANIA data has finished downloading.");
      out.close();
      if (!data.delete()) {
        LOG.error("Couldn't delete GeneMANIA .zip: " + data.getAbsolutePath());
      }

    } catch (IOException ex) {
      java.util.logging.Logger.getLogger(GenemaniaInfoRetriever.class.getName())
          .log(Level.SEVERE, null, ex);
    }
  }
Example #5
0
 /**
  * Gets the picture data as a byte array.
  *
  * <p>Note, that this call might be expensive since all the picture data is copied into a
  * temporary byte array. You can grab the picture data directly from the underlying package part
  * as follows: <br>
  * <code>
  * InputStream is = getPackagePart().getInputStream();
  * </code>
  *
  * @return the picture data.
  */
 public byte[] getData() {
   try {
     return IOUtils.toByteArray(getPackagePart().getInputStream());
   } catch (IOException e) {
     throw new POIXMLException(e);
   }
 }
Example #6
0
 /** check if a picture with this picture data already exists in this presentation */
 XSLFPictureData findPictureData(byte[] pictureData) {
   long checksum = IOUtils.calculateChecksum(pictureData);
   for (XSLFPictureData pic : getAllPictures()) {
     if (pic.getChecksum() == checksum) {
       return pic;
     }
   }
   return null;
 }
 /**
  * Gets the picture data as a byte array.
  *
  * <p>Note, that this call might be expensive since all the picture data is copied into a
  * temporary byte array. You can grab the picture data directly from the underlying package part
  * as follows: <br>
  * <code>
  * InputStream is = getPackagePart().getInputStream();
  * </code>
  *
  * @return the Picture data.
  */
 public byte[] getData() {
   try {
     return IOUtils.toByteArray(getPackagePart().getInputStream());
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   return null;
 }
  /**
   * Create a POIFSFileSystem from an <tt>InputStream</tt>. Normally the stream is read until EOF.
   * The stream is always closed.
   *
   * <p>Some streams are usable after reaching EOF (typically those that return <code>true</code>
   * for <tt>markSupported()</tt>). In the unlikely case that the caller has such a stream
   * <i>and</i> needs to use it after this constructor completes, a work around is to wrap the
   * stream in order to trap the <tt>close()</tt> call. A convenience method (
   * <tt>createNonClosingInputStream()</tt>) has been provided for this purpose:
   *
   * <pre>
   * InputStream wrappedStream = POIFSFileSystem.createNonClosingInputStream(is);
   * HSSFWorkbook wb = new HSSFWorkbook(wrappedStream);
   * is.reset();
   * doSomethingElse(is);
   * </pre>
   *
   * Note also the special case of <tt>ByteArrayInputStream</tt> for which the <tt>close()</tt>
   * method does nothing.
   *
   * <pre>
   * ByteArrayInputStream bais = ...
   * HSSFWorkbook wb = new HSSFWorkbook(bais); // calls bais.close() !
   * bais.reset(); // no problem
   * doSomethingElse(bais);
   * </pre>
   *
   * @param stream the InputStream from which to read the data
   * @exception IOException on errors reading, or on invalid data
   */
  public NPOIFSFileSystem(InputStream stream) throws IOException {
    this(false);

    ReadableByteChannel channel = null;
    boolean success = false;

    try {
      // Turn our InputStream into something NIO based
      channel = Channels.newChannel(stream);

      // Get the header
      ByteBuffer headerBuffer = ByteBuffer.allocate(POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
      IOUtils.readFully(channel, headerBuffer);

      // Have the header processed
      _header = new HeaderBlock(headerBuffer);

      // Sanity check the block count
      BlockAllocationTableReader.sanityCheckBlockCount(_header.getBATCount());

      // We need to buffer the whole file into memory when
      //  working with an InputStream.
      // The max possible size is when each BAT block entry is used
      int maxSize = BATBlock.calculateMaximumSize(_header);
      ByteBuffer data = ByteBuffer.allocate(maxSize);
      // Copy in the header
      headerBuffer.position(0);
      data.put(headerBuffer);
      data.position(headerBuffer.capacity());
      // Now read the rest of the stream
      IOUtils.readFully(channel, data);
      success = true;

      // Turn it into a DataSource
      _data = new ByteArrayBackedDataSource(data.array(), data.position());
    } finally {
      // As per the constructor contract, always close the stream
      if (channel != null) channel.close();
      closeInputStream(stream, success);
    }

    // Now process the various entries
    readCoreContents();
  }
 public void uploadFile(FileUploadEvent event) throws IOException {
   CartexDesign cartexDesign = CartexDesignService.getCartexDesignByUserId(user.getId());
   if (cartexDesign != null) {
     cartexDesign.setImage(IOUtils.toByteArray(event.getFile().getInputstream()));
     CartexDesignService.editCartexDesign(cartexDesign);
   } else {
     CartexDesignService.addCartexDesign(
         user.getId(),
         "",
         "",
         "",
         "",
         "",
         "",
         "",
         "",
         IOUtils.toByteArray(event.getFile().getInputstream()));
   }
   init();
 }
Example #10
0
 /**
  * Creates or updates and image. Creates a thumbSizexthumbSize thumbnail called thumb_idImage.
  *
  * @param file Uploaded file
  * @param idImage name of the file to write.
  * @param oldIdImage Delete this image and its thumbnail
  */
 public void creatOrUpdateImage(
     UploadedFile file, String idImage, String oldIdImage, Integer thumbSize) {
   if (file != null) {
     try {
       storeImage(idImage, IOUtils.toByteArray(file.getInputstream()));
       resizeImage(idImage);
       createThumbnail(idImage, thumbSize, thumb_pre);
       deleteOld(oldIdImage);
     } catch (IOException e) {
       System.out.println(">>>>> idImage = " + idImage);
     }
   }
 }
  @Override
  protected Map<String, Object> executeImpl(WebScriptRequest req, Status status, Cache cache) {
    // Check we got a valid Multi-Part Form Upload
    FormData form = (FormData) req.parseContent();
    if (form == null || !form.getIsMultiPart()) {
      throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Bad Upload");
    }

    // Look for a file, we're quite flexible!
    File spreadsheet = null;
    for (FormData.FormField field : form.getFields()) {
      if (field.getIsFile()) {
        String ext = ".xls";
        if (field.getFilename() != null && field.getFilename().endsWith(".xlsx")) {
          ext = ".xlsx";
        }

        try {
          spreadsheet = TempFileProvider.createTempFile("spreadsheet", ext);
          FileOutputStream sout = new FileOutputStream(spreadsheet);
          IOUtils.copy(field.getInputStream(), sout);
          sout.close();
        } catch (IOException e) {
          throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Upload Failed");
        }

        break;
      }
    }

    // Process
    String[] sheetnames = null;
    if (spreadsheet != null) {
      try {
        sheetnames = excerpter.getSheetNames(spreadsheet);
      } catch (IOException e) {
        throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Spreadsheet Corrupt", e);
      }
    } else {
      throw new WebScriptException(Status.STATUS_BAD_REQUEST, "Spreadsheet Missing");
    }

    // Report
    Map<String, Object> model = new HashMap<String, Object>();
    model.put("file", spreadsheet.getName());
    model.put("sheets", sheetnames);
    return model;
  }
Example #12
0
  @Test
  public void test() throws Throwable {
    Workbook wb =
        WorkbookFactory.create(new File(Resources.getResource("excel/employees.xlsx").getFile()));
    Sheet sheet = wb.getSheet("employees");
    Iterator<Row> itr = sheet.iterator();
    itr.next();
    List<Employee> employees = new LinkedList<>();
    while (itr.hasNext()) {
      employees.add(populate(itr.next()));
    }
    IOUtils.closeQuietly(wb);

    Assert.assertEquals(2, employees.size());
    TestUtils.print(employees);
  }
Example #13
0
  /**
   * Checks that the supplied InputStream (which MUST support mark and reset, or be a
   * PushbackInputStream) has a POIFS (OLE2) header at the start of it. If your InputStream does not
   * support mark / reset, then wrap it in a PushBackInputStream, then be sure to always use that,
   * and not the original!
   *
   * @param inp An InputStream which supports either mark/reset, or is a PushbackInputStream
   */
  public static boolean hasPOIFSHeader(InputStream inp) throws IOException {
    // We want to peek at the first 8 bytes
    inp.mark(8);

    byte[] header = new byte[8];
    IOUtils.readFully(inp, header);
    LongField signature = new LongField(HeaderBlockConstants._signature_offset, header);

    // Wind back those 8 bytes
    if (inp instanceof PushbackInputStream) {
      PushbackInputStream pin = (PushbackInputStream) inp;
      pin.unread(header);
    } else {
      inp.reset();
    }

    // Did it match the signature?
    return (signature.get() == HeaderBlockConstants._signature);
  }
Example #14
0
  /**
   * Creates the appropriate HSSFWorkbook / XSSFWorkbook from the given InputStream, which may be
   * password protected.
   *
   * <p>Your input stream MUST either support mark/reset, or be wrapped as a {@link
   * PushbackInputStream}! Note that using an {@link InputStream} has a higher memory footprint than
   * using a {@link File}.
   *
   * <p>Note that in order to properly release resources the Workbook should be closed after use.
   * Note also that loading from an InputStream requires more memory than loading from a File, so
   * prefer {@link #create(File)} where possible.
   *
   * @throws EncryptedDocumentException If the wrong password is given for a protected file
   * @throws EmptyFileException If an empty stream is given
   */
  public static Workbook create(InputStream inp, String password)
      throws IOException, InvalidFormatException, EncryptedDocumentException {
    // If clearly doesn't do mark/reset, wrap up
    if (!inp.markSupported()) {
      inp = new PushbackInputStream(inp, 8);
    }

    // Ensure that there is at least some data there
    byte[] header8 = IOUtils.peekFirst8Bytes(inp);

    // Try to create
    if (POIFSFileSystem.hasPOIFSHeader(header8)) {
      NPOIFSFileSystem fs = new NPOIFSFileSystem(inp);
      return create(fs, password);
    }
    if (POIXMLDocument.hasOOXMLHeader(inp)) {
      return new XSSFWorkbook(OPCPackage.open(inp));
    }
    throw new IllegalArgumentException(
        "Your InputStream was neither an OLE2 stream, nor an OOXML stream");
  }
 /**
  * Generador de la vista previa para balance General.
  *
  * @param out Buffer de salida.
  * @param data Datos enviados para poder generar la vista previa. Opcional.
  */
 public void vistaPrevia(OutputStream out, Object data) {
   FileInputStream fileInputStream = null;
   try {
     File file = new File(this.pathArchivoFisico);
     fileInputStream = new FileInputStream(file);
     out.write(IOUtils.toByteArray(fileInputStream));
   } catch (FileNotFoundException ex) {
     LOGGER.log(
         Level.SEVERE,
         "No se puede obtener la referencia al archivo fisico en el file system.",
         ex);
   } catch (IOException ex) {
     LOGGER.log(
         Level.SEVERE, "Problemas para operar con el archivo fisico en el file system.", ex);
   } finally {
     try {
       fileInputStream.close();
     } catch (IOException ex) {
       this.sinErrores = false;
       LOGGER.log(Level.SEVERE, null, ex);
     }
   }
 }
  // will throw IOException if not actually POIFS
  // can return null byte[]
  private byte[] handleEmbeddedPOIFS(
      InputStream is, Metadata metadata, AtomicInteger unknownFilenameCount) throws IOException {

    NPOIFSFileSystem fs = null;
    byte[] ret = null;
    try {

      fs = new NPOIFSFileSystem(is);

      DirectoryNode root = fs.getRoot();

      if (root == null) {
        return ret;
      }

      if (root.hasEntry("Package")) {
        Entry ooxml = root.getEntry("Package");
        TikaInputStream stream =
            TikaInputStream.get(new DocumentInputStream((DocumentEntry) ooxml));

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        IOUtils.copy(stream, out);
        ret = out.toByteArray();
      } else {
        // try poifs
        POIFSDocumentType type = POIFSDocumentType.detectType(root);
        if (type == POIFSDocumentType.OLE10_NATIVE) {
          try {
            // Try to un-wrap the OLE10Native record:
            Ole10Native ole = Ole10Native.createFromEmbeddedOleObject(root);
            ret = ole.getDataBuffer();
          } catch (Ole10NativeException ex) {
            // Not a valid OLE10Native record, skip it
          }
        } else if (type == POIFSDocumentType.COMP_OBJ) {

          DocumentEntry contentsEntry;
          try {
            contentsEntry = (DocumentEntry) root.getEntry("CONTENTS");
          } catch (FileNotFoundException ioe) {
            contentsEntry = (DocumentEntry) root.getEntry("Contents");
          }

          DocumentInputStream inp = null;
          try {
            inp = new DocumentInputStream(contentsEntry);
            ret = new byte[contentsEntry.getSize()];
            inp.readFully(ret);
          } finally {
            if (inp != null) {
              inp.close();
            }
          }
        } else {

          ByteArrayOutputStream out = new ByteArrayOutputStream();
          is.reset();
          IOUtils.copy(is, out);
          ret = out.toByteArray();
          metadata.set(
              Metadata.RESOURCE_NAME_KEY,
              "file_" + unknownFilenameCount.getAndIncrement() + "." + type.getExtension());
          metadata.set(Metadata.CONTENT_TYPE, type.getType().toString());
        }
      }
    } finally {
      if (fs != null) {
        fs.close();
      }
    }
    return ret;
  }
  protected RestVariable createBinaryExecutionVariable(
      Execution execution,
      int responseVariableType,
      UriInfo uriInfo,
      boolean isNew,
      MultipartBody multipartBody) {

    boolean debugEnabled = log.isDebugEnabled();
    Response.ResponseBuilder responseBuilder = Response.ok();

    List<org.apache.cxf.jaxrs.ext.multipart.Attachment> attachments =
        multipartBody.getAllAttachments();

    int attachmentSize = attachments.size();

    if (attachmentSize <= 0) {
      throw new ActivitiIllegalArgumentException("No Attachments found with the request body");
    }
    AttachmentDataHolder attachmentDataHolder = new AttachmentDataHolder();

    for (int i = 0; i < attachmentSize; i++) {
      org.apache.cxf.jaxrs.ext.multipart.Attachment attachment = attachments.get(i);

      String contentDispositionHeaderValue = attachment.getHeader("Content-Disposition");
      String contentType = attachment.getHeader("Content-Type");

      if (debugEnabled) {
        log.debug("Going to iterate:" + i);
        log.debug("contentDisposition:" + contentDispositionHeaderValue);
      }

      if (contentDispositionHeaderValue != null) {
        contentDispositionHeaderValue = contentDispositionHeaderValue.trim();

        Map<String, String> contentDispositionHeaderValueMap =
            Utils.processContentDispositionHeader(contentDispositionHeaderValue);
        String dispositionName = contentDispositionHeaderValueMap.get("name");
        DataHandler dataHandler = attachment.getDataHandler();

        OutputStream outputStream = null;

        if ("name".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Attachment Name Reading error occured", e);
          }

          if (outputStream != null) {
            String fileName = outputStream.toString();
            attachmentDataHolder.setName(fileName);
          }

        } else if ("type".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Attachment Type Reading error occured", e);
          }

          if (outputStream != null) {
            String typeName = outputStream.toString();
            attachmentDataHolder.setType(typeName);
          }

        } else if ("scope".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException(
                "Attachment Description Reading error occured", e);
          }

          if (outputStream != null) {
            String description = outputStream.toString();
            attachmentDataHolder.setScope(description);
          }
        }

        if (contentType != null) {
          if ("file".equals(dispositionName)) {

            InputStream inputStream = null;
            try {
              inputStream = dataHandler.getInputStream();
            } catch (IOException e) {
              throw new ActivitiIllegalArgumentException(
                  "Error Occured During processing empty body.", e);
            }

            if (inputStream != null) {
              attachmentDataHolder.setContentType(contentType);
              byte[] attachmentArray = new byte[0];
              try {
                attachmentArray = IOUtils.toByteArray(inputStream);
              } catch (IOException e) {
                throw new ActivitiIllegalArgumentException("Processing Attachment Body Failed.", e);
              }
              attachmentDataHolder.setAttachmentArray(attachmentArray);
            }
          }
        }
      }
    }

    attachmentDataHolder.printDebug();

    if (attachmentDataHolder.getName() == null) {
      throw new ActivitiIllegalArgumentException("Attachment name is required.");
    }

    if (attachmentDataHolder.getAttachmentArray() == null) {
      throw new ActivitiIllegalArgumentException(
          "Empty attachment body was found in request body after " + "decoding the request" + ".");
    }
    String variableScope = attachmentDataHolder.getScope();
    String variableName = attachmentDataHolder.getName();
    String variableType = attachmentDataHolder.getType();

    if (log.isDebugEnabled()) {
      log.debug(
          "variableScope:"
              + variableScope
              + " variableName:"
              + variableName
              + " variableType:"
              + variableType);
    }

    try {

      // Validate input and set defaults
      if (variableName == null) {
        throw new ActivitiIllegalArgumentException("No variable name was found in request body.");
      }

      if (variableType != null) {
        if (!RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE.equals(variableType)
            && !RestResponseFactory.SERIALIZABLE_VARIABLE_TYPE.equals(variableType)) {
          throw new ActivitiIllegalArgumentException(
              "Only 'binary' and 'serializable' are supported as variable type.");
        }
      } else {
        variableType = RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE;
      }

      RestVariable.RestVariableScope scope = RestVariable.RestVariableScope.LOCAL;
      if (variableScope != null) {
        scope = RestVariable.getScopeFromString(variableScope);
      }

      if (variableType.equals(RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE)) {
        // Use raw bytes as variable value
        setVariable(
            execution, variableName, attachmentDataHolder.getAttachmentArray(), scope, isNew);

      } else {
        // Try deserializing the object
        InputStream inputStream =
            new ByteArrayInputStream(attachmentDataHolder.getAttachmentArray());
        ObjectInputStream stream = new ObjectInputStream(inputStream);
        Object value = stream.readObject();
        setVariable(execution, variableName, value, scope, isNew);
        stream.close();
      }

      if (responseVariableType == RestResponseFactory.VARIABLE_PROCESS) {
        return new RestResponseFactory()
            .createBinaryRestVariable(
                variableName,
                scope,
                variableType,
                null,
                null,
                execution.getId(),
                uriInfo.getBaseUri().toString());
      } else {
        return new RestResponseFactory()
            .createBinaryRestVariable(
                variableName,
                scope,
                variableType,
                null,
                execution.getId(),
                null,
                uriInfo.getBaseUri().toString());
      }

    } catch (IOException ioe) {
      throw new ActivitiIllegalArgumentException("Could not process multipart content", ioe);
    } catch (ClassNotFoundException ioe) {
      throw new BPMNContentNotSupportedException(
          "The provided body contains a serialized object for which the class is nog found: "
              + ioe.getMessage());
    }
  }
Example #18
0
  public static void main(String[] args) throws Exception {
    StringBuilder jsonDataBuilder = new StringBuilder();
    //		jsonDataBuilder.append("{\"project\": {\"Name\": \"XDocReport\",\"URL\":
    // \"http://code.google.com/p/xdocreport/\"},");
    //		jsonDataBuilder.append("\"developers\": [");
    //		jsonDataBuilder.append("{\"Name\": \"我\",");
    //		jsonDataBuilder.append("\"Mail\": \"[email protected]\",");
    //		jsonDataBuilder.append("\"LastName\": \"Angelo\"},");
    //		jsonDataBuilder.append("{\"Name\": \"DDD\",");
    //		jsonDataBuilder.append("\"Mail\": \"[email protected]\",");
    //		jsonDataBuilder.append("\"LastName\": \"Pascal\"}]}");

    //		jsonDataBuilder.append("{\"sendInfoHotel\": {\"HotelName\": \"我\"}}");

    //		jsonDataBuilder.append("{\"Guest\":{\"Name\": \"我\",\"First\":
    // \"[email protected]\",\"LastName\": \"Angelo\"}}");

    jsonDataBuilder.append("{");
    jsonDataBuilder.append(
        "\"hotel\": {\"Name\": \"昆仑石基大酒店\", \"URL\": \"http://www.shijinet.cn/\"},");
    jsonDataBuilder.append("\"guests\": [");
    jsonDataBuilder.append("{");
    jsonDataBuilder.append("\"Name\": \"李卓\",");
    jsonDataBuilder.append("\"Mail\": \"[email protected]\",");
    jsonDataBuilder.append("\"summaryPrice\": \"$999999\"");
    jsonDataBuilder.append("},");
    jsonDataBuilder.append("{");
    jsonDataBuilder.append("\"Name\": \"赵谦\",");
    jsonDataBuilder.append("\"Mail\": \"[email protected]\",");
    jsonDataBuilder.append("\"summaryPrice\": \"$999999\"");
    jsonDataBuilder.append("}");
    jsonDataBuilder.append("]}");
    String jsonData = jsonDataBuilder.toString();

    JSONObject jsonObject = JSONObject.fromObject(jsonData);
    System.out.println(jsonObject);

    HttpPost httpPost = new HttpPost("http://localhost:8080/kunlun-rest-reporting/rest/report/CRS");
    httpPost.setHeader("Content-type", "application/json");
    httpPost.setEntity(new StringEntity(jsonData, "UTF-8"));

    // 使用HttpClient发送POST请求
    HttpClient httpClient = new DefaultHttpClient();
    // 执行发送
    HttpResponse response = httpClient.execute(httpPost);

    // 得到结果码
    int httpStatusCode = response.getStatusLine().getStatusCode();
    System.out.println("httpStatusCode:" + httpStatusCode);

    // get file name
    Header header = response.getFirstHeader("Content-Disposition");
    System.out.println("header.getValue():" + header.getValue());
    String fileNameTemp = header.getValue().replace(ATTACHMENT_FILENAME_START, "");
    String fileName = fileNameTemp.replace(ATTACHMENT_FILENAME_END, "");
    // inputstreamtofile(in, new File("E://zhaozhaozhao" + fileName));

    // get file
    InputStream in = response.getEntity().getContent();
    byte[] bytes = IOUtils.toByteArray(in);
    FileOutputStream fos = new FileOutputStream("E://zhaozhaozhao" + fileName);
    fos.write(bytes);
    fos.close();

    httpClient.getConnectionManager().shutdown();
  }