wake-up-neo.net

Datei in JSONObject an senden REST Internetservice

Ich möchte eine Datei an Webservice senden, aber ich muss weitere Informationen senden, also möchte ich sie mit einem Json senden. Wenn ich jedoch eine Datei in mein jsonObject stecke, erhalte ich die Fehlermeldung, dass es sich nicht um eine Zeichenfolge handelt. Meine Frage ist, sollte ich meine Datei nehmen und in eine Zeichenfolge konvertieren, sie dann in meinen Json einfügen und auf einem Webdienst diese Datei in eine Datei umwandeln? Oder gibt es einen anderen einfachen Weg?

Hier ist mein Code:

Klient:

private void send() throws JSONException{
    ClientConfig config = new DefaultClientConfig();
    Client client = Client.create(config);
    client.addFilter(new LoggingFilter());
    WebResource service = client.resource("http://localhost:8080/proj/rest/file/upload_json");

    JSONObject my_data = new JSONObject();
    File file_upload = new File("C:/hi.txt");
    my_data.put("User", "Beth");
    my_data.put("Date", "22-07-2013");
    my_data.put("File", file_upload);

    ClientResponse client_response = service.accept(MediaType.APPLICATION_JSON).post(ClientResponse.class, my_data);

    System.out.println("Status: "+client_response.getStatus());

    client.destroy();
}

Internetservice

@POST
@Path("/upload_json")

@Consumes(MediaType.APPLICATION_JSON)
@Produces("text/plain")

public String receive(JSONObject json) throws JSONException {

    //Here I'll save my file and make antoher things..
    return "ok";
}

Nach all den Antworten hier mein Code - Danke an alle:

Internetservice

import Java.io.File;
import Java.io.FileOutputStream;
import Java.io.IOException;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import com.Sun.jersey.core.util.Base64;

@Path("/file")
public class ReceiveJSONWebService {

    @POST
    @Path("/upload_json")

    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)

    public JSONObject receiveJSON(JSONObject json) throws JSONException, IOException {
        convertFile(json.getString("file"), json.getString("file_name"));
        //Prints my json object
        return json;
    }

    //Convert a Base64 string and create a file
    private void convertFile(String file_string, String file_name) throws IOException{
        byte[] bytes = Base64.decode(file_string);
        File file = new File("local_path/"+file_name);
        FileOutputStream fop = new FileOutputStream(file);
        fop.write(bytes);
        fop.flush();
        fop.close();
    }
}

Klient

import Java.io.File;
import Java.io.IOException;
import Java.nio.file.Files;
import javax.ws.rs.core.MediaType;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import com.Sun.jersey.api.client.Client;
import com.Sun.jersey.api.client.ClientResponse;
import com.Sun.jersey.api.client.WebResource;
import com.Sun.jersey.api.client.config.ClientConfig;
import com.Sun.jersey.api.client.config.DefaultClientConfig;
import com.Sun.jersey.api.client.filter.LoggingFilter;
import com.Sun.jersey.core.util.Base64;
import com.Sun.jersey.multipart.FormDataMultiPart;
import com.Sun.jersey.multipart.file.FileDataBodyPart;
import com.Sun.jersey.multipart.impl.MultiPartWriter;

public class MyClient {


    public static void main(String[] args) throws JSONException, IOException 
    {
        MyClient my_client = new MyClient();
        File file_upload = new File("local_file/file_name.pdf");
        my_client.sendFileJSON(file_upload);
    }


    private void sendFileJSON(File file_upload) throws JSONException, IOException{

        ClientConfig config = new DefaultClientConfig();
        Client client = Client.create(config);
        client.addFilter(new LoggingFilter());
        WebResource service = client.resource("my_rest_address_path");
        JSONObject data_file = new JSONObject();
        data_file.put("file_name", file_upload.getName());
        data_file.put("description", "Something about my file....");
        data_file.put("file", convertFileToString(file_upload));

        ClientResponse client_response = service.accept(MediaType.APPLICATION_JSON).post(ClientResponse.class, data_file);

        System.out.println("Status: "+client_response.getStatus());

        client.destroy();

    }


    //Convert my file to a Base64 String
    private String convertFileToString(File file) throws IOException{
        byte[] bytes = Files.readAllBytes(file.toPath());   
        return new String(Base64.encode(bytes));
    }

}
18
user2486187

Sie sollten die Dateidaten in eine Base64-Kodierung konvertieren und diese dann übertragen, z. so was:

byte[] bytes = Files.readAllBytes(file_upload.toPath());
dados.put("File", DatatypeConverter.printBase64Binary(bytes));
8
Moritz Petersen
@POST
@Path("/uploadWeb")
@Consumes(MediaType.MULTIPART_FORM_DATA)
public Response uploadWeb(  @FormDataMultiPart("image")     InputStream uploadedInputStream,
                @FormDataParam("image")     FormDataContentDisposition fileDetail ) {

    int read = 0;
    byte[] bytes = new byte[1024];
    while ((read = uploadedInputStream.read(bytes)) != -1)
        System.out.write(bytes, 0, read);
    return Response.status(HttpStatus.SC_OK).entity(c).build();
 }

und der Client-Seite ( siehe diesen Beitrag) :

HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost(url);
FileBody fileContent= new FileBody(new File(fileName));
StringBody comment = new StringBody("Filename: " + fileName);
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart("file", fileContent);
httppost.setEntity(reqEntity);
HttpResponse response = httpclient.execute(httppost);
HttpEntity resEntity = response.getEntity();
2
moshe beeri

Ich weiß, es ist ein alter Beitrag, aber ich dachte nur, ich würde ein wenig hinzufügen, um die Abhängigkeit von externen Bibliotheken zu vermeiden.

//Convert my file to a Base64 String
public static final String convertFileToString(File file) throws IOException{
   byte[] bytes = Files.readAllBytes(file.toPath());   
   return new String(Base64.getEncoder().encode(bytes));
}

//Convert a Base64 string and create a file
public static final void convertFile(String file_string, String file_name) throws IOException{
   byte[] bytes = Base64.getDecoder().decode(file_string);
   File file = new File("local_path/"+file_name);
   FileOutputStream fop = new FileOutputStream(file);
   fop.write(bytes);
   fop.flush();
   fop.close();
}
1
Palmeta

Ich weiß nicht, worauf sich dados bezieht, möglicherweise ein Map<String, String>, aber ich denke, Sie möchten die soeben erstellte JSONObject verwenden

JSONObject my_data = new JSONObject();
File file_upload = new File("C:/hi.txt");
my_data.put("User", "Beth");
my_data.put("Date", "22-07-2013");
my_data.put("File", file_upload);

Dies ist jedoch nutzlos und macht möglicherweise nicht das, was Sie denken. Ein File-Objekt enthält keine Datei, es enthält den Pfad zur Datei, dh. C:/hi.txt. Wenn es das ist, was Sie in Ihrem JSON einsetzen, wird es produzieren

{"File" : "C:/hi.txt"}

Es enthält nicht den Dateiinhalt.

Sie können also genauso einfach den Dateipfad direkt angeben

JSONObject my_data = new JSONObject();
my_data.put("User", "Beth");
my_data.put("Date", "22-07-2013");
my_data.put("File", "C:/hi.txt");

Wenn Sie versuchen, eine Datei mit JSON hochzuladen, können Sie die Bytes mit NIO von Java 7 aus der Datei lesen

byte[] bytes = Files.readAllBytes(file_upload .toPath());

Base64 kodiert diese Bytes und schreibt sie als String in das JSONObject. Apache Commons-Codec verwenden

Base64.encodeBase64(bytes);
my_data.put("File", new String(bytes));

Ändern Sie bitte die Rechneradresse von localhost in ip-Adresse. Sie möchten, dass sich Ihr Client mit dem unten genannten Dienst verbindet.

**CLIENT TO CALL REST WEBSERVICE**


    package in.india.client.downloadfiledemo;

    import Java.io.BufferedInputStream;
    import Java.io.File;
    import Java.io.FileInputStream;
    import Java.io.FileNotFoundException;
    import Java.io.FileOutputStream;
    import Java.io.IOException;

    import javax.ws.rs.core.MediaType;
    import javax.ws.rs.core.Response.Status;

    import com.Sun.jersey.api.client.Client;
    import com.Sun.jersey.api.client.ClientHandlerException;
    import com.Sun.jersey.api.client.ClientResponse;
    import com.Sun.jersey.api.client.UniformInterfaceException;
    import com.Sun.jersey.api.client.WebResource;
    import com.Sun.jersey.multipart.BodyPart;
    import com.Sun.jersey.multipart.MultiPart;

    public class DownloadFileClient {

        private static final String BASE_URI = "http://localhost:8080/DownloadFileDemo/services/downloadfile";

        public DownloadFileClient() {

            try {
                Client client = Client.create();
                WebResource objWebResource = client.resource(BASE_URI);
                ClientResponse response = objWebResource.path("/")
                        .type(MediaType.TEXT_HTML).get(ClientResponse.class);

                System.out.println("response : " + response);
                if (response.getStatus() == Status.OK.getStatusCode()
                        && response.hasEntity()) {
                    MultiPart objMultiPart = response.getEntity(MultiPart.class);
                    Java.util.List<BodyPart> listBodyPart = objMultiPart
                            .getBodyParts();
                    BodyPart filenameBodyPart = listBodyPart.get(0);
                    BodyPart fileLengthBodyPart = listBodyPart.get(1);
                    BodyPart fileBodyPart = listBodyPart.get(2);

                    String filename = filenameBodyPart.getEntityAs(String.class);
                    String fileLength = fileLengthBodyPart
                            .getEntityAs(String.class);
                    File streamedFile = fileBodyPart.getEntityAs(File.class);

                    BufferedInputStream objBufferedInputStream = new BufferedInputStream(
                            new FileInputStream(streamedFile));

                    byte[] bytes = new byte[objBufferedInputStream.available()];

                    objBufferedInputStream.read(bytes);

                    String outFileName = "D:/"
                            + filename;
                    System.out.println("File name is : " + filename
                            + " and length is : " + fileLength);
                    FileOutputStream objFileOutputStream = new FileOutputStream(
                            outFileName);
                    objFileOutputStream.write(bytes);
                    objFileOutputStream.close();
                    objBufferedInputStream.close();
                    File receivedFile = new File(outFileName);
                    System.out.print("Is the file size is same? :\t");
                    System.out.println(Long.parseLong(fileLength) == receivedFile
                            .length());
                }
            } catch (UniformInterfaceException e) {
                e.printStackTrace();
            } catch (ClientHandlerException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        public static void main(String... args) {
            new DownloadFileClient();
        }

    }


**SERVICE TO RESPONSE CLIENT** 

package in.india.service.downloadfiledemo;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import com.Sun.jersey.multipart.MultiPart;

@Path("downloadfile")
@Produces("multipart/mixed")
public class DownloadFileResource {

    @GET
    public Response getFile() {

        Java.io.File objFile = new Java.io.File(
                "D:/DanGilbert_2004-480p-en.mp4");
        MultiPart objMultiPart = new MultiPart();
        objMultiPart.type(new MediaType("multipart", "mixed"));
        objMultiPart
                .bodyPart(objFile.getName(), new MediaType("text", "plain"));
        objMultiPart.bodyPart("" + objFile.length(), new MediaType("text",
                "plain"));
        objMultiPart.bodyPart(objFile, new MediaType("multipart", "mixed"));

        return Response.ok(objMultiPart).build();

    }

}

**JAR NEEDED** 

jersey-bundle-1.14.jar
jersey-multipart-1.14.jar
mimepull.jar

**WEB.XML**


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://Java.Sun.com/xml/ns/javaee" xmlns:web="http://Java.Sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://Java.Sun.com/xml/ns/javaee http://Java.Sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>DownloadFileDemo</display-name>
    <servlet>
        <display-name>JAX-RS REST Servlet</display-name>
        <servlet-name>JAX-RS REST Servlet</servlet-name>
        <servlet-class>com.Sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
        <init-param>
             <param-name>com.Sun.jersey.config.property.packages</param-name> 
             <param-value>in.india.service.downloadfiledemo</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>JAX-RS REST Servlet</servlet-name>
        <url-pattern>/services/*</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>
0