Tengo una API externa que utiliza ELIMINAR con el cuerpo(JSON). Puedo hacer uso de Cartero RESTO del Cliente y conseguir la eliminación hecho con el cuerpo de solicitud y funciona bien. Estoy tratando de automatizar esta funcionalidad usando un método.

Traté de HttpURLConnection similares GET, POST y PUT. Pero no estoy seguro de cómo utilizar el ELIMINAR con un cuerpo de solicitud.

He comprobado en StackOverflow y ver esto no se puede hacer, pero son muy viejas respuestas.

Por favor alguien puede ayudar? Estoy usando el framework spring.

  • Ayuda esto a usted? stackoverflow.com/questions/299628/…. Parece que con ELIMINAR el cuerpo de solicitud debe ser ignorado.
  • He leído el artículo, sin embargo, la API externa que yo uso se ha de tener en el cuerpo
  • Que API de terceros es esto? Es una API de terceros utilizados por un producto de terceros, o de una API de terceros utilizados por un producto que están desarrollando? En el primer caso, está bastante atascado con ella, pero en el último caso, su organización puede elegir el uso de una biblioteca con una más comunes (mejor compatible) sintaxis.
  • Es una en la casa de la aplicación de servicio de mi organización, accesible sólo a través de la misma red. Estoy intentando conseguir que la producción de la API con mi API.
  • Normalmente sólo POST, PUT y REVISIÓN de solicitud de uso de los cuerpos, así que al menos que no es una API REST – parece ser un mal diseño.
InformationsquelleAutor DXBKing | 2017-04-05

4 Comentarios

  1. 9

    He utilizado org.apache.http para hacer esto.

    @NotThreadSafe
    class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase {
        public static final String METHOD_NAME = "DELETE";
    
        public String getMethod() {
            return METHOD_NAME;
        }
    
        public HttpDeleteWithBody(final String uri) {
            super();
            setURI(URI.create(uri));
        }
    
        public HttpDeleteWithBody(final URI uri) {
            super();
            setURI(uri);
        }
    
        public HttpDeleteWithBody() {
            super();
        }
    }
    
    
    
    public String[] sendDelete(String URL, String PARAMS, String header) throws IOException {
        String[] restResponse = new String[2];
            CloseableHttpClient httpclient = HttpClients.createDefault();
    
            HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(URL);
            StringEntity input = new StringEntity(PARAMS, ContentType.APPLICATION_JSON);
            httpDelete.addHeader("header", header);
            httpDelete.setEntity(input);  
    
            Header requestHeaders[] = httpDelete.getAllHeaders();
            CloseableHttpResponse response = httpclient.execute(httpDelete);
            restResponse[0] = Integer.toString((response.getStatusLine().getStatusCode()));
            restResponse[1] = EntityUtils.toString(response.getEntity());    
            return restResponse;
        }
    }
  2. 1

    Si usted está utilizando la Primavera, se puede utilizar RestTemplate para generar la solicitud del cliente. En este caso podría utilizar RestTemplate.exchange y proporcionar la dirección url, el método http y del cuerpo de solicitud. Algo así como (no probado, pero usted consigue la idea):

    RestTemplate restTemplate = new RestTemplate();
    HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
    restTemplate.exchange(url, HttpMethod.DELETE, request, null);
    • Esto va a soltar el cuerpo y siempre regreso 400
  3. 1

    Este código funcionó para mí:-

    • Se establece el tipo de contenido por httpCon.setRequestProperty
    • Establece el Método de solicitud por httpCon.setRequestMethod
    • Escribir el json cuerpo en OutputStreamWriter, en mi ejemplo, me he convertido en Java objeto json utilizando Jackson ObjectMapper

      URL url = new URL("http://localhost:8080/greeting");
      HttpURLConnection httpCon = (HttpURLConnection) url.openConnection();
      httpCon.setDoOutput(true);
      httpCon.setRequestProperty(
                      "Content-Type", "application/json");
      httpCon.setRequestMethod("DELETE");
      OutputStreamWriter out = new OutputStreamWriter(
                      httpCon.getOutputStream());
      ObjectMapper objectMapper = new ObjectMapper();
      out.write(objectMapper.writeValueAsString(new Greeting("foo")));
      out.close();
      httpCon.connect();
  4. -1

    No es fácil reemplazar la getMethod() método de la HttpPost clase?

    private String curl(                    //Return JSON String
    String method,                  //HTTP method, for this example the method parameter should be "DELETE", but it could be PUT, POST, or GET.
    String url,                     //Target URL  
    String path,                    //API Path
    Map<String, Object> queryParams,//Query map forms URI
    Map<String, Object> postParams) //Post Map serialized to JSON and is put in the header
    throws Error,               //when API returns an error
    ConnectionClosedException       //when we cannot contact the API
    {
    HttpClient client = HttpClients.custom()
    .setDefaultRequestConfig(
    RequestConfig.custom()
    .setCookieSpec(CookieSpecs.STANDARD)
    .build()
    ).build();
    HttpPost req = new HttpPost(){
    @Override
    public String getMethod() {
    //lets override the getMethod since it is the only
    //thing that differs between each of the subclasses
    //of HttpEntityEnclosingRequestBase. Let's just return
    //our method parameter in the curl method signature.
    return method;
    }
    };
    //set headers
    req.setHeader("user-agent", "Apache");
    req.setHeader("Content-type", "application/json");
    req.setHeader("Accept", "application/json");
    try {
    //prepare base url
    URIBuilder uriBuilder = new URIBuilder(url + path);
    if (method.equals("GET")){
    queryParams.forEach((k, v)-> uriBuilder.addParameter(k, v.toString()));
    }else{
    String postPramsJson = new Gson().toJson(postParams);
    req.setEntity(new StringEntity(postPramsJson));
    }
    //set the uri
    req.setURI(uriBuilder.build().normalize());
    //execute the query
    final HttpResponse response = client.execute(req);
    //
    if (response.getEntity() != null) {
    if(response.getStatusLine().getStatusCode() == 200){
    return EntityUtils.toString(response.getEntity());
    }
    logger.error("ERROR: Response code " + response.getStatusLine().getStatusCode() +
    ", respnse: " + EntityUtils.toString(responseEntry));
    }
    throw new Error("HTTP Error");
    } catch (Exception e) {
    logger.error("Connection error", e);
    throw new ConnectionClosedException("Cannot connect to " + url);
    }
    }

    El punto es que en lugar de tener que agregar otra clase que a su paquete… ¿por Qué no reemplazar getMethod() en una sub-clasificado objeto de HttpEntityEnclosingRequestBase?

Dejar respuesta

Please enter your comment!
Please enter your name here