Java FileDataBodyPart类代码示例

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
/**
 * Test to make sure that the proxy can proxy a redirect
 * @throws Exception
 */
@Test
public void testPassThroughPostMultiPart() throws Exception {
    final FileDataBodyPart filePart = new FileDataBodyPart("test_file", new File(TEST_IMAGE_PATH));

    MultiPart multiPart = new FormDataMultiPart()
            .field("foo", "bar")
            .bodyPart(filePart);
    Client multipartClient = ClientBuilder.newBuilder()
            .register(MultiPartFeature.class)
            .build();
    String responseBody = multipartClient.target("http://localhost:" + RULE.getLocalPort() + "/proxy")
            .request()
            .header("proxy-url", "http://httpbin.org/post")
            .post(Entity.entity(multiPart, multiPart.getMediaType()))
            .readEntity(String.class);
    assertTrue(responseBody.toLowerCase().contains("test_file"));
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Override
public APIResponse sendFax(final String faxNumber,
                           final File[] filesToSendAsFax,
                           final Optional<SendFaxOptions> options) throws IOException, URISyntaxException {

    MultiPart multiPart = new MultiPart();
    int count = 1;
    for (File file : filesToSendAsFax) {
        String contentType = tika.detect(file);
        String entityName = "file"+count++;
        FileDataBodyPart fileDataBodyPart = new FileDataBodyPart(entityName, file, MediaType.valueOf(contentType));
        multiPart.bodyPart(fileDataBodyPart);
    }

    return sendMultiPartFax(faxNumber, multiPart, options);
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
private String saveCreativeMultipleUploads(StringBuilder uri, List<T1File> fileList, String collection)
		throws ClientException, IOException {
	if (fileList == null) {
		throw new ClientException("please enter a valid filename and file path");
	}

	String path = t1Service.constructUrl(uri, collection);

	FormDataMultiPart multipart = new FormDataMultiPart();

	for (T1File t1File : fileList) {
		if (t1File != null
				&& (t1File.getFile() != null && t1File.getFilename() != null && t1File.getName() != null)) {
			FileDataBodyPart filePart = new FileDataBodyPart("file", new File(t1File.getFile()));

			multipart.field("filename", t1File.getFilename()).field("name", t1File.getName()).bodyPart(filePart);
		}
	}

	Response responseObj = this.connection.post(path, multipart, this.user);
	String response = responseObj.readEntity(String.class);

	multipart.close();

	return response;
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
public static void main(String[] args) throws IOException
{
    final Client client = ClientBuilder.newBuilder().register(MultiPartFeature.class).build();
 
    final FileDataBodyPart filePart = new FileDataBodyPart("file", new File("/tmp/Sample.pdf"));
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    final FormDataMultiPart multipart = (FormDataMultiPart) formDataMultiPart.field("foo", "bar").bodyPart(filePart);
      
    final WebTarget target = client.target(getBaseURI());
    final Response response = target.request().post(Entity.entity(multipart, multipart.getMediaType()));
     
    //Use response object to verify upload success
     if (response.getStatus() != 200) {
          throw new RuntimeException("Failed : HTTP error code : "
           + response.getStatus());
       } else {
		System.out.println("Data uploaded successfully !!\n");
	}	
    
    formDataMultiPart.close();
    multipart.close();
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Test
public void testPostDoNotOwn() throws IOException {
    Focus focus = new Focus();
    focus.setAuthoruserguid("88888888-8888-8888-8888-888888888888");
    currentUser.setGuid("99999999-9999-9999-9999-999999999999");
    
    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    MultiPart multipart = formDataMultiPart.bodyPart(new FileDataBodyPart("file", Paths.get("pom.xml").toFile()));

    when(focusRepository.loadOrNotFound("00000000-0000-0000-0000-000000000000")).thenReturn(focus);

    Response response = target().path("/picture/focus/00000000-0000-0000-0000-000000000000").request()
            .post(Entity.entity(multipart, multipart.getMediaType()));

    assertEquals(400, response.getStatus());

    verify(focusRepository).loadOrNotFound("00000000-0000-0000-0000-000000000000");

    formDataMultiPart.close();
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Test
    public void shouldUploadAFile() {
        Path path = Paths.get(System.getProperty("user.dir"),
                              "src", "test", "resources", "rest", "IFrameProxyTestData.html");
        FileDataBodyPart filePart = new FileDataBodyPart("file", path.toFile());
        filePart.setContentDisposition(FormDataContentDisposition.name("file")
                                               .fileName("IFrameProxyTestData.html")
                                               .build());
        MultiPart multipartEntity = new FormDataMultiPart().bodyPart(filePart);
        Response response = target("/projects/" + PROJECT_TEST_ID + "/files")
                                .register(MultiPartFeature.class)
                                .request()
                                .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA));
        System.out.println(" -> " + response.readEntity(String.class));
//        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
    }
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
/**
 * @{inheritDoc
 */
public String runAutomationJob(AutomationRequest request, File xmlFile)
        throws RestServiceException {
	WebTarget webTarget = client.target(baseUrl + METHOD_RUN_JOB);
    MultiPart multiPart = new MultiPart();
    if (xmlFile != null) {
        BodyPart bp = new FileDataBodyPart("file", xmlFile);
        multiPart.bodyPart(bp);
    }

    multiPart.bodyPart(new FormDataBodyPart("automationRequest", request,
            MediaType.APPLICATION_XML_TYPE));
    Response response = webTarget.request().post(Entity.entity(multiPart, MediaType.MULTIPART_FORM_DATA_TYPE));
    exceptionHandler.checkStatusCode(response);
    return response.readEntity(String.class);
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
public void update(TransifexResource resource, String content) throws IOException {

        Path fileToUpload = Files.createTempFile("fileToUpload", ".tmp");
        Files.write(fileToUpload, content.getBytes(StandardCharsets.UTF_8));

        FormDataMultiPart multiPart = new FormDataMultiPart();
        multiPart.bodyPart(new FileDataBodyPart("file", fileToUpload.toFile()));

        String method;

        StringBuilder url = new StringBuilder();
        url.append(API_ROOT);
        url.append("/project/");
        url.append(resource.getProjectSlug());

        if (resourceExists(resource)) {
            method = "PUT";
            url.append("/resource/");
            url.append(resource.getResourceSlug());
            url.append("/content/");
        } else {
            method = "POST";
            url.append("/resources/");
            multiPart.field("slug", resource.getResourceSlug());
            multiPart.field("name", resource.getSourceFile());
            multiPart.field("i18n_type", resource.getType());
        }

        WebTarget webTarget = client.target(TARGET_URL + url);
        Response response = webTarget.request().method(method, Entity.entity(multiPart, multiPart.getMediaType()));

        String jsonData = response.readEntity(String.class);

        if (response.getStatus() / 100 != 2) {
            LOGGER.debug(jsonData);
            throw new IOException("Transifex API call has failed. Status code: " + response.getStatus());
        }

        LOGGER.debug(jsonData);
    }
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Override
public String uploadFile(String user, String project, File apk) {
	FormDataMultiPart form = new FormDataMultiPart();
	form.field("userId", user);
	form.field("projectId", project);
	form.bodyPart(new FileDataBodyPart("file", apk, MediaType.APPLICATION_OCTET_STREAM_TYPE));
	MediaType contentType = MediaType.MULTIPART_FORM_DATA_TYPE;
	contentType = Boundary.addBoundary(contentType);

	return target.path("upload").path("file").request().post(Entity.entity(form, contentType), String.class);
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Test
public void testUploadArchive() throws IOException {
	File zip = new File(getClass().getClassLoader()
			.getResource("upload.zip").getFile());

	final FormDataMultiPart multipart = new FormDataMultiPart();
	FileDataBodyPart filePart = new FileDataBodyPart("udc_archive_"
			+ zip.getName(), zip);
	multipart.bodyPart(filePart);
	

	final Response response = target.path("queue/myApp").request()
			.post(Entity.entity(multipart, multipart.getMediaType()));

	String result=response.readEntity(String.class);
	assertTrue(result.contains("Files: [upload.zip] queued")
			|| result.contains("Files: [] queued"));
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
private void uploadPath(final String name, final String id, final Path path) {
    final Client client = ClientBuilder.newClient();

    client.register(MultiPartFeature.class);

    final WebTarget target = client.target(uri).path(
            uri.getPath() + "_exposr/publish/" + name + "/" + id);

    final FileDataBodyPart filePart = new FileDataBodyPart("file",
            path.toFile(),
            MediaType.APPLICATION_OCTET_STREAM_TYPE);

    final MultiPart multipart = new FormDataMultiPart().bodyPart(filePart);

    Response response = target.request(MediaType.APPLICATION_JSON_TYPE)
            .put(Entity.entity(multipart, multipart.getMediaType()));
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
/**
 * Tests whether a document can be added by uploading it.
 */
@Test
public void testAddDocument() {
  FileDataBodyPart dataPart = new FileDataBodyPart("file", new File(TEST_FILE_PATH));

  FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
  formDataMultiPart.bodyPart(dataPart);

  Entity<FormDataMultiPart> multiPartEntity = Entity.entity(formDataMultiPart,
                                                            formDataMultiPart.getMediaType());

  DocumentIdResponse actualResponse = target("documents").request()
                                        .post(multiPartEntity, DocumentIdResponse.class);

  assertNotNull(actualResponse);

  // TODO The analyis is not stopped, so it will try to continue until
  // the next test empties the database and it fails. It would be better
  // to stop the analysis here
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
private void upload(String server, String environment, File file, boolean dryRun) throws Exception {
    JerseyClient client = new JerseyClientBuilder()
    		.register(HttpAuthenticationFeature.basic("user", "pass")) // set.getUser(), set.getPass()
    		.register(MultiPartFeature.class)
    		.build();
    JerseyWebTarget t = client.target(UriBuilder.fromUri(server).build()).path("rest").path("items").path("upload");

    FileDataBodyPart filePart = new FileDataBodyPart("file", file);
    String fn = file.getName();
    fn = fn.substring(0, fn.lastIndexOf("_report") + 7); // die tempnummer am ende des filenamens noch wegoperieren!
	System.out.println(fn);
    filePart.setContentDisposition(FormDataContentDisposition.name("file").fileName(fn).build());

    FormDataMultiPart formDataMultiPart = new FormDataMultiPart();
    MultiPart multipartEntity = formDataMultiPart.field("comment", "Analysis from BfR").bodyPart(filePart);

    if (!dryRun) {
	    Response response = t.queryParam("environment", environment).request().post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA));
	    System.out.println(response.getStatus() + " \n" + response.readEntity(String.class));

	    response.close();
    }

    formDataMultiPart.close();
    multipartEntity.close();
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
@Test
public void tabularUpload() {
  Client client = ClientBuilder.newBuilder().register(MultiPartFeature.class).build();
  String dataSetId = "dataset" + UUID.randomUUID().toString().replace("-", "_");
  WebTarget target = client.target(
    format(
      "http://localhost:%d/v5/" + PREFIX + "/" + dataSetId + "/upload/table?forceCreation=true",
      APP.getLocalPort()
    )
  );

  FormDataMultiPart multiPart = new FormDataMultiPart();
  multiPart.setMediaType(MediaType.MULTIPART_FORM_DATA_TYPE);
  FileDataBodyPart fileDataBodyPart = new FileDataBodyPart(
    "file",
    new File(getResource(IntegrationTest.class, "2017_04_17_BIA_Clusius.xlsx").getFile()),
    new MediaType("application", "vnd.openxmlformats-officedocument.spreadsheetml.sheet")
  );
  multiPart.bodyPart(fileDataBodyPart);
  multiPart.field("type", "xlsx");


  Response response = target.request()
    .header(HttpHeaders.AUTHORIZATION, "fake")
    .post(Entity.entity(multiPart, multiPart.getMediaType()));

  assertThat(response.getStatus(), Matchers.is(201));
  // assertThat(response.getHeaderString(HttpHeaders.LOCATION), Matchers.is(notNullValue()));
}
 

import org.glassfish.jersey.media.multipart.file.FileDataBodyPart; //导入依赖的package包/类
/**
 * Creates a new data store.
 *
 * @param file      CSV file that should be uploaded (N.B. max 50MB)
 * @param name      name to use in the Load Impact web-console
 * @param fromline  Payload from this line (1st line is 1). Set to value 2, if the CSV file starts with a headings line
 * @param separator field separator, one of {@link com.loadimpact.resource.DataStore.Separator}
 * @param delimiter surround delimiter for text-strings, one of {@link com.loadimpact.resource.DataStore.StringDelimiter}
 * @return {@link com.loadimpact.resource.DataStore}
 */
public DataStore createDataStore(final File file, final String name, final int fromline, final DataStore.Separator separator, final DataStore.StringDelimiter delimiter) {
    return invoke(DATA_STORES,
            new RequestClosure<JsonObject>() {
                @Override
                public JsonObject call(Invocation.Builder request) {
                    MultiPart form = new FormDataMultiPart()
                            .field("name", name)
                            .field("fromline", Integer.toString(fromline))
                            .field("separator", separator.param())
                            .field("delimiter", delimiter.param())
                            .bodyPart(new FileDataBodyPart("file", file, new MediaType("text", "csv")));

                    return request.post(Entity.entity(form, form.getMediaType()), JsonObject.class);
                }
            },
            new ResponseClosure<JsonObject, DataStore>() {
                @Override
                public DataStore call(JsonObject json) {
                    return new DataStore(json);
                }
            }
    );
}