Convertidor de Curl a Java

Convierte comandos curl a código Java - Genera código Java HttpClient listo para usar para peticiones API

Datenschutzhinweis: Esta herramienta profesional proporciona conversión segura a código Java con protección de privacidad de nivel empresarial. No almacenamos ningún dato que envíes, asegurando completa confidencialidad para tu trabajo de desarrollo API.

Generador de Código Java HttpClient

// Java HttpClient code will appear here
// Example:
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class HttpClientExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .connectTimeout(Duration.ofSeconds(10))
                .build();
                
        String jsonBody = "{\"name\": \"test\"}";
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();
                
        HttpResponse response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
                
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

Comandos curl Comunes para Pruebas de API en Java

Aquí hay algunos comandos curl comunes que puedes convertir a código Java:

Ejemplos de Java HttpClient

La biblioteca HttpClient de Java (introducida en Java 11) es una forma potente y moderna de hacer peticiones HTTP. Aquí hay algunos patrones comunes de Java HttpClient:

Subida de Archivos con Java HttpClient

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileUploadExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .build();
                
        Path path = Paths.get("document.pdf");
        String boundary = "----WebKitFormBoundary" + System.currentTimeMillis();
        String contentType = "multipart/form-data; boundary=" + boundary;
        
        // Create multipart form data
        String data = "--" + boundary + "\r\n" +
                "Content-Disposition: form-data; name=\"file\"; filename=\"" + path.getFileName() + "\"\r\n" +
                "Content-Type: application/pdf\r\n\r\n";
                
        byte[] fileData = Files.readAllBytes(path);
        byte[] requestBody = new byte[data.getBytes().length + fileData.length + ("\r\n--" + boundary + "--\r\n").getBytes().length];
        
        System.arraycopy(data.getBytes(), 0, requestBody, 0, data.getBytes().length);
        System.arraycopy(fileData, 0, requestBody, data.getBytes().length, fileData.length);
        System.arraycopy(("\r\n--" + boundary + "--\r\n").getBytes(), 0, requestBody, 
                data.getBytes().length + fileData.length, ("\r\n--" + boundary + "--\r\n").getBytes().length);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/upload"))
                .header("Content-Type", contentType)
                .header("Authorization", "Bearer YOUR_TOKEN_HERE")
                .POST(HttpRequest.BodyPublishers.ofByteArray(requestBody))
                .build();
                
        HttpResponse response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
                
        System.out.println(response.body());
    }
}

Java HttpClient con Timeout y Manejo de Errores

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class ErrorHandlingExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .connectTimeout(Duration.ofSeconds(5))
                .build();
                
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .timeout(Duration.ofSeconds(5))
                .GET()
                .build();
                
        try {
            HttpResponse response = client.send(request, 
                    HttpResponse.BodyHandlers.ofString());
                    
            int statusCode = response.statusCode();
            if (statusCode >= 200 && statusCode < 300) {
                System.out.println("Success: " + response.body());
            } else {
                System.out.println("Error: " + statusCode + " - " + response.body());
            }
        } catch (IOException e) {
            System.out.println("Connection error: " + e.getMessage());
        } catch (InterruptedException e) {
            System.out.println("Request interrupted: " + e.getMessage());
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            System.out.println("Error making request: " + e.getMessage());
        }
    }
}

Cómo Usar el Convertidor de Java HttpClientr

1. Grundlegende Nutzung

Copia tu comando curl → Pégalo en la caja de entrada → Obtén código Java HttpClient convertido

2. Características de Java HttpClient

  • HTTP methods (GET, POST, PUT, DELETE, etc.)
  • Request headers in Java format
  • JSON and form data handling
  • Basic and token authentication
  • SSL verification options
  • Session handling with Java HttpClient

3. Uso Avanzado de Java HttpClient

Nuestro convertidor soporta comandos curl complejos y los traduce a código Java limpio y eficiente usando la biblioteca HttpClient

4. Convertir Opciones de curl a Java

Nuestra herramienta maneja estas opciones comunes de curl y las convierte a código Java HttpClient apropiado:

  • -X, --request: Sets the HTTP method (GET, POST, PUT, etc.)
  • -H, --header: Adds HTTP headers to the request
  • -d, --data: Sends data in the request body
  • --data-binary: Sends binary data in the request body
  • -u, --user: Adds basic authentication
  • -k, --insecure: Disables SSL certificate verification
  • --connect-timeout: Sets connection timeout

Preguntas Frecuentes sobre Java HttpClient

P: ¿Qué versión de Java se requiere para el código generado?

R: El código Java HttpClient generado requiere Java 11 o superior. Para versiones anteriores de Java, considera usar clientes HTTP alternativos como Apache HttpClient o OkHttp.

P: ¿El código Java maneja la verificación de errores?

R: El código básico generado incluye bloques try/catch para IOException e InterruptedException. Para código de producción, es posible que desees añadir un manejo de errores más específico para diferentes códigos de estado HTTP.

P: ¿Cómo puedo procesar la respuesta en Java?

R: La biblioteca HttpClient proporciona varios BodyHandlers para procesar respuestas. Usa HttpResponse.BodyHandlers.ofString() para respuestas de texto, ofInputStream() para datos binarios, u ofByteArray() para bytes en bruto.

P: ¿Necesito instalar alguna biblioteca para usar el código generado?

R: No se requieren bibliotecas externas. El HttpClient es parte de la biblioteca estándar de Java desde Java 11. Para procesamiento JSON, es posible que desees añadir una biblioteca como Jackson o Gson.

P: ¿Cómo convierto un comando curl con subida de archivos a Java?

R: Para subidas de archivos en Java, necesitarás usar datos de formulario multipart con HttpClient. Nuestro convertidor maneja comandos curl con opciones -F o --form y genera el código Java apropiado.

P: ¿Cómo manejo cookies en Java HttpClient?

R: El HttpClient de Java proporciona manejo de cookies a través del método HttpClient.Builder.cookieHandler(). Cuando conviertes comandos curl que incluyen manejo de cookies (usando -b o --cookie), nuestra herramienta genera código Java que gestiona adecuadamente las cookies.

P: ¿Cuál es la diferencia entre usar curl y Java HttpClient para pruebas de API?

R: Mientras que curl es excelente para pruebas rápidas de API en línea de comandos, Java HttpClient proporciona un enfoque programático que se integra con tus aplicaciones Java. Convertir curl a Java ayuda a cerrar la brecha entre pruebas e implementación en el desarrollo Java.

Referencia de Comandos Curl para Pruebas de API en Java

Entender los comandos curl es esencial para pruebas efectivas de API con Java. Aquí hay una referencia rápida de opciones comunes de curl que nuestro convertidor soporta:

Sintaxis Básica de curl

curl [options] [URL]

Opciones Comunes de curl

Convertir Comandos curl Complejos

Nuestro convertidor Java maneja comandos curl complejos incluyendo múltiples cabeceras, autenticación, cargas de datos y varias opciones. Simplemente pega tu comando curl y obtén código Java limpio y moderno usando la biblioteca HttpClient.

Mejores Prácticas de Java HttpClient

Cuando trabajes con la biblioteca Java HttpClient, sigue estas mejores prácticas para interacciones API eficientes y seguras:

1. Reutiliza Instancias de HttpClient

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class HttpClientReuseExample {
    // Create a single HttpClient instance for the application
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .build();
            
    public static void main(String[] args) throws Exception {
        // First request
        HttpRequest request1 = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/users"))
                .GET()
                .build();
        HttpResponse response1 = httpClient.send(request1, 
                HttpResponse.BodyHandlers.ofString());
                
        // Second request (uses same client)
        HttpRequest request2 = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/products"))
                .GET()
                .build();
        HttpResponse response2 = httpClient.send(request2, 
                HttpResponse.BodyHandlers.ofString());
    }
}

2. Implementa un Manejo de Errores Adecuado

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpTimeoutException;

public class ErrorHandlingBestPractice {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET()
                .build();
                
        try {
            HttpResponse response = client.send(request, 
                    HttpResponse.BodyHandlers.ofString());
                    
            switch (response.statusCode()) {
                case 200:
                case 201:
                    System.out.println("Success: " + response.body());
                    break;
                case 400:
                    System.out.println("Bad request: " + response.body());
                    break;
                case 401:
                case 403:
                    System.out.println("Authentication error: " + response.statusCode());
                    break;
                case 404:
                    System.out.println("Resource not found");
                    break;
                case 500:
                case 503:
                    System.out.println("Server error: " + response.statusCode());
                    break;
                default:
                    System.out.println("Unexpected status: " + response.statusCode());
            }
        } catch (HttpTimeoutException e) {
            System.out.println("Request timed out: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Network error: " + e.getMessage());
        } catch (InterruptedException e) {
            System.out.println("Request interrupted");
            Thread.currentThread().interrupt();
        }
    }
}

3. Usa Peticiones Asíncronas para Mejor Rendimiento

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class AsyncRequestExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET()
                .build();
                
        CompletableFuture> futureResponse = 
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
                
        futureResponse
            .thenApply(HttpResponse::body)
            .thenAccept(System.out::println)
            .exceptionally(e -> {
                System.err.println("Error: " + e.getMessage());
                return null;
            });
            
        // Do other work while the request is processing
        System.out.println("Request sent asynchronously...");
        
        // Wait for the request to complete if needed
        futureResponse.join();
    }
}

Convertir curl a Otros Lenguajes

PHP Python JavaScript Go Ruby Java