Quer aprender a criar e consumir uma API REST em Java puro? Este guia prático te mostra como fazer isso, utilizando com.sun.net.httpserver para criar a API e java.net.HttpURLConnection para consumi-la. Vamos construir um servidor HTTP simples e um cliente para interagir com ele, tudo em Java puro. Prepare-se para colocar a mão na massa e criar sua própria API!
Estrutura do Projeto
Antes de começar a codificar, é importante organizar o projeto. A estrutura de diretórios que usaremos é a seguinte:
src
└── main
└── java
├── api
│ ├── Task.java // Modelo de dados
│ ├── TaskHandler.java // Manipulador de requisições
│ └── Server.java // Servidor principal
└── client
└── ApiClient.java // Cliente para consumir a API
Essa estrutura facilita a organização do código, separando as classes responsáveis pela API (servidor) das classes responsáveis por consumir a API (cliente). Dentro do pacote api, teremos o modelo de dados (Task.java), o manipulador de requisições (TaskHandler.java) e o servidor principal (Server.java). No pacote client, teremos a classe ApiClient.java, que será responsável por interagir com a API.
Código do Servidor
Agora, vamos implementar o código do servidor, começando com a classe Task, que representa o modelo de dados.
Classe Task (Modelo)
A classe Task é um modelo simples que representa uma tarefa com um ID, título e status de conclusão. Veja o código:
package api;
public class Task {
private int id;
private String title;
private boolean completed;
// Construtor, getters e setters
public Task(int id, String title, boolean completed) {
this.id = id;
this.title = title;
this.completed = completed;
}
public int getId() { return id; }
public String getTitle() { return title; }
public boolean isCompleted() { return completed; }
}
Esta classe define os atributos de uma tarefa e fornece métodos para acessar esses atributos. O construtor permite criar instâncias de Task com valores iniciais para ID, título e status de conclusão. Os métodos getId(), getTitle() e isCompleted() são getters que retornam os valores dos respectivos atributos.
Classe TaskHandler (Manipulador de Requisições)
A classe TaskHandler é responsável por manipular as requisições HTTP que chegam ao servidor. Ela implementa a interface HttpHandler e define a lógica para lidar com diferentes métodos HTTP, como GET e POST. Veja o código:
package api;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
public class TaskHandler implements HttpHandler {
private List<Task> tasks = new ArrayList<>();
private int nextId = 1;
@Override
public void handle(HttpExchange exchange) throws IOException {
String method = exchange.getRequestMethod();
String path = exchange.getRequestURI().getPath();
switch (method) {
case "GET":
handleGet(exchange);
break;
case "POST":
handlePost(exchange);
break;
default:
sendResponse(exchange, 405, "{\"error\": \"Método não permitido\"}");
}
}
private void handleGet(HttpExchange exchange) throws IOException {
String json = "[";
for (Task task : tasks) {
json += String.format(
"{\"id\": %d, \"title\": \"%s\", \"completed\": %b},",
task.getId(), task.getTitle(), task.isCompleted()
);
}
json = json.isEmpty() ? "[]" : json.substring(0, json.length() - 1) + "]";
sendResponse(exchange, 200, json);
}
private void handlePost(HttpExchange exchange) throws IOException {
String body = new String(exchange.getRequestBody().readAllBytes());
// Simples parsing (em produção, use uma biblioteca JSON)
String title = body.split("\"")[3]; // Extrai o título do JSON
Task task = new Task(nextId++, title, false);
tasks.add(task);
sendResponse(exchange, 201, "{\"id\": " + task.getId() + "}");
}
private void sendResponse(HttpExchange exchange, int statusCode, String response) throws IOException {
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(statusCode, response.getBytes().length);
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}
}
A classe TaskHandler mantém uma lista de tarefas (tasks) e um contador para gerar IDs únicos (nextId). O método handle() é o ponto de entrada para todas as requisições. Ele verifica o método HTTP e o caminho da requisição e chama o método apropriado para lidar com a requisição. Os métodos handleGet() e handlePost() implementam a lógica para listar tarefas e criar novas tarefas, respectivamente. O método sendResponse() envia a resposta HTTP de volta para o cliente.
Classe Server (Iniciar Servidor)
A classe Server é responsável por iniciar o servidor HTTP e registrar o TaskHandler para lidar com as requisições na rota /tasks. Veja o código:
package api;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
public class Server {
public static void main(String[] args) throws IOException {
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
server.createContext("/tasks", new TaskHandler());
server.start();
System.out.println("Servidor iniciado na porta 8080");
}
}
O método main() cria uma instância de HttpServer, registra o TaskHandler para a rota /tasks e inicia o servidor na porta 8080. Ele também imprime uma mensagem no console informando que o servidor foi iniciado.
Consumindo a API com ApiClient
Agora que o servidor está pronto, vamos criar um cliente para interagir com a API. A classe ApiClient será responsável por enviar requisições HTTP para o servidor e receber as respostas. Veja o código:
package client;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.InputStream;
import java.util.Scanner;
public class ApiClient {
public static String get(String url) throws IOException {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
conn.setRequestMethod("GET");
try (InputStream is = conn.getInputStream();
Scanner scanner = new Scanner(is)) {
return scanner.useDelimiter("\\A").next();
}
}
public static String post(String url, String jsonBody) throws IOException {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes());
}
try (InputStream is = conn.getInputStream();
Scanner scanner = new Scanner(is)) {
return scanner.useDelimiter("\\A").next();
}
}
public static void main(String[] args) {
try {
// POST: Criar uma tarefa
String responsePost = post("http://localhost:8080/tasks",
"{\"title\": \"Aprender Java\", \"completed\": false}");
System.out.println("POST Response: " + responsePost);
// GET: Listar tarefas
String responseGet = get("http://localhost:8080/tasks");
System.out.println("GET Response: " + responseGet);
} catch (IOException e) {
e.printStackTrace();
}
}
}
A classe ApiClient possui métodos para enviar requisições GET e POST para o servidor. O método get() envia uma requisição GET para a URL especificada e retorna a resposta do servidor como uma String. O método post() envia uma requisição POST com um corpo JSON para a URL especificada e retorna a resposta do servidor como uma String. O método main() demonstra como usar os métodos get() e post() para interagir com a API.
Execução
Para executar o servidor e o cliente, siga os seguintes passos:
-
Inicie o Servidor:
java api.Server -
Execute o Cliente:
java client.ApiClient
Testando com cURL (Opcional)
Se preferir, você pode testar a API usando o cURL, uma ferramenta de linha de comando para fazer requisições HTTP. Aqui estão alguns exemplos:
# Criar tarefa
curl -X POST -H "Content-Type: application/json" -d "{\"title\":\"Estudar API\",\"completed\":false}" http://localhost:8080/tasks
# Listar tarefas
curl http://localhost:8080/tasks
Considerações Finais
Este guia mostrou como criar e consumir uma API REST em Java puro de forma simples e direta. No entanto, é importante ter em mente algumas considerações:
-
Simplicidade vs. Robustez:
- O servidor usa com.sun.net.httpserver, ideal para protótipos. Em produção, prefira frameworks como Spring Boot ou Javalin.
- O parsing de JSON é simplificado. Use bibliotecas como Jackson ou Gson para manipulação real de JSON.
-
Cliente HTTP:
- Para projetos reais, use HttpClient (Java 11+) ou bibliotecas como OkHttp.
-
Melhorias Possíveis:
- Adicionar tratamento de erros.
- Implementar métodos PUT e DELETE.
- Validar entradas.
Com este conhecimento, você pode começar a construir APIs mais complexas e robustas em Java. Lembre-se de explorar as bibliotecas e frameworks disponíveis para facilitar o desenvolvimento e garantir a qualidade do seu código.
Este conteúdo foi auxiliado por Inteligência Artificial, mas escrito e revisado por um humano.Via Dev.to