HTTP Basics in Java

Su Suriya Ravichandran Updated 18 Nov 2026
12 min read ·Lesson 267 of 306

HTTP (Hypertext Transfer Protocol) is the text-based protocol that browsers, mobile apps and servers use to talk to each other. Every Java web technology, from servlets to Spring Boot, is built on top of it. Learning HTTP basics in Java first makes the later web lessons much easier, because a servlet is simply Java code that reads an HTTP request and writes an HTTP response.

This lesson uses two tools that ship with the JDK: the small com.sun.net.httpserver.HttpServer to play the server, and curl or java.net.http.HttpClient to play the client. No libraries or containers are needed.


How HTTP Works: Request and Response

HTTP is a request–response protocol. The client opens a TCP connection, sends one request, and the server sends back one response.

 Client (browser, curl, HttpClient)            Server (Tomcat, HttpServer)
        |                                              |
        |  GET /hello HTTP/1.1                         |
        |  Host: localhost:8000                        |
        |--------------------------------------------->|
        |                                              |
        |                     HTTP/1.1 200 OK          |
        |                     Content-Type: text/plain |
        |                     Hello from Java HTTP!    |
        |<---------------------------------------------|
PartRequestResponse
First lineMethod, path, version: GET /hello HTTP/1.1Version, status code, reason: HTTP/1.1 200 OK
HeadersName: value lines, such as Host and AcceptName: value lines, such as Content-Type
Blank lineEnds the headersEnds the headers
BodyOptional (form data, JSON)Optional (HTML, JSON, images)

How it works:

  • HTTP/1.1 messages are plain text lines ending in \r\n. HTTP/2 and HTTP/3 send the same information in a binary format, but the methods, headers and status codes are identical.
  • HTTP runs over TCP, the same kind of connection you used in Java Socket. HTTPS is HTTP inside an encrypted TLS connection.

Create a Simple HTTP Server in Java

The JDK includes a lightweight HTTP server in the jdk.httpserver module. It is ideal for learning, tests and small tools.

// HelloHttpServer.java
import com.sun.net.httpserver.HttpServer;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;

public class HelloHttpServer {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);

        server.createContext("/hello", exchange -> {
            byte[] body = "Hello from Java HTTP!\n".getBytes(StandardCharsets.UTF_8);
            exchange.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8");
            exchange.sendResponseHeaders(200, body.length);   // status + body length
            try (OutputStream out = exchange.getResponseBody()) {
                out.write(body);
            }
        });

        server.start();
        System.out.println("Listening on http://localhost:8000/hello");
    }
}

Run it and call it with curl -i, which prints the response headers too:

java HelloHttpServer.java
curl -i http://localhost:8000/hello

Output:

HTTP/1.1 200 OK
Date: Tue, 17 Nov 2026 12:30:00 GMT
Content-type: text/plain; charset=utf-8
Content-length: 22

Hello from Java HTTP!

How it works:

  • createContext("/hello", handler) maps a path to a handler. The handler receives an HttpExchange, which holds both the request and the response.
  • sendResponseHeaders(200, length) writes the status line and headers. After that you can only write the body.
  • The server adds Date and Content-length itself. It prints header names with only the first letter in capitals (Content-type), which is allowed because HTTP header names are case-insensitive.
  • java HelloHttpServer.java compiles and runs a single source file in one step.

Read the Parts of an HTTP Request

The next handler prints the request line and every header, so you can see exactly what a client sends. Add it, and the other handlers in this lesson, to HelloHttpServer before server.start().

server.createContext("/echo", exchange -> {
    System.out.println(exchange.getRequestMethod() + " "
            + exchange.getRequestURI() + " " + exchange.getProtocol());

    // TreeMap sorts header names so the output is easy to read
    new java.util.TreeMap<>(exchange.getRequestHeaders())
            .forEach((name, values) -> System.out.println(name + ": " + String.join(", ", values)));

    exchange.sendResponseHeaders(204, -1);   // 204 No Content, no body
    exchange.close();
});
curl http://localhost:8000/echo?course=java

Output in the server terminal:

GET /echo?course=java HTTP/1.1
Accept: */*
Host: localhost:8000
User-agent: curl/8.5.0

How it works:

  • The request line has three parts: the method (GET), the request target (/echo?course=java) and the protocol version.
  • Host is required in HTTP/1.1. It lets one server host many websites on the same IP address.
  • A length of -1 in sendResponseHeaders means "no body", which is correct for status 204.

HTTP Methods

The method tells the server what the client wants to do with the resource named in the path.

MethodPurposeHas body?SafeIdempotent
GETRead a resourceNoYesYes
POSTCreate a resource or submit dataYesNoNo
PUTReplace a resource completelyYesNoYes
PATCHChange part of a resourceYesNoNo
DELETERemove a resourceUsually noNoYes
HEADSame as GET but headers onlyNoYesYes
OPTIONSAsk which methods are allowedNoYesYes

How it works:

  • Safe means the request does not change data on the server. Browsers and crawlers may send safe requests freely.
  • Idempotent means sending the same request twice has the same effect as sending it once. Deleting student 7 twice still leaves student 7 deleted, but posting the same order twice creates two orders.

The handler below reacts differently to each method:

server.createContext("/method", exchange -> {
    String reply = switch (exchange.getRequestMethod()) {
        case "GET"    -> "You asked to read data";
        case "POST"   -> "You sent new data";
        case "DELETE" -> "You asked to delete data";
        default       -> "Method not handled";
    };
    byte[] body = (reply + "\n").getBytes(StandardCharsets.UTF_8);
    exchange.sendResponseHeaders(200, body.length);
    try (OutputStream out = exchange.getResponseBody()) { out.write(body); }
});
curl http://localhost:8000/method
curl -X POST http://localhost:8000/method
curl -X DELETE http://localhost:8000/method

Output:

You asked to read data
You sent new data
You asked to delete data

How it works:

  • curl -X sets the method. Without it, curl sends GET.
  • getRequestMethod() returns the method name in capitals, so a switch on strings works well.

HTTP Status Codes

The status code is a three-digit number that tells the client how the request went. The first digit gives the category.

RangeMeaningCommon codes
1xxInformational101 Switching Protocols (WebSocket upgrade)
2xxSuccess200 OK, 201 Created, 204 No Content
3xxRedirection301 Moved Permanently, 302 Found, 304 Not Modified
4xxClient error400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 405 Method Not Allowed
5xxServer error500 Internal Server Error, 503 Service Unavailable

Use HttpClient to check the status of several paths:

// StatusCheck.java  (run while HelloHttpServer is running)
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class StatusCheck {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        for (String path : new String[] {"/hello", "/echo", "/missing"}) {
            HttpRequest request = HttpRequest.newBuilder(URI.create("http://localhost:8000" + path)).build();
            HttpResponse<Void> response = client.send(request, HttpResponse.BodyHandlers.discarding());
            System.out.println(path + " -> " + response.statusCode());
        }
    }
}

Output:

/hello -> 200
/echo -> 204
/missing -> 404

How it works:

  • HttpServer answers 404 by itself when no context matches the path.
  • BodyHandlers.discarding() ignores the body, because only the status is needed. The full client API is covered in Java HttpClient.

Note: A 4xx code means the client must change the request. A 5xx code means the server failed, and the same request may work later.


HTTP Headers

Headers carry extra information about the message. Some describe the body, some control caching, and some identify the client.

HeaderSent byExampleMeaning
Content-TypeBothapplication/json; charset=utf-8Format of the body
Content-LengthBoth42Body size in bytes
AcceptClientapplication/jsonFormats the client can read
User-AgentClientcurl/8.5.0Client software
AuthorizationClientBearer abc123Credentials
LocationServer/students/4Where a new or moved resource is
Cache-ControlServerno-storeCaching rules
Set-Cookie / CookieServer / Clientvisits=3Small state stored in the browser

The handler below chooses the format from the Accept header:

server.createContext("/course", exchange -> {
    String accept = exchange.getRequestHeaders().getFirst("Accept");
    boolean wantsJson = accept != null && accept.contains("application/json");

    String body = wantsJson ? "{\"course\":\"Java\",\"lessons\":306}\n" : "Course: Java (306 lessons)\n";
    String type = wantsJson ? "application/json" : "text/plain";

    byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
    exchange.getResponseHeaders().set("Content-Type", type + "; charset=utf-8");
    exchange.sendResponseHeaders(200, bytes.length);
    try (OutputStream out = exchange.getResponseBody()) { out.write(bytes); }
});
curl http://localhost:8000/course
curl -H "Accept: application/json" http://localhost:8000/course

Output:

Course: Java (306 lessons)
{"course":"Java","lessons":306}

How it works:

  • getFirst("Accept") returns the first value of the header, or null if the client did not send it. The lookup ignores case.
  • Choosing the response format from Accept is called content negotiation.

Query Strings and URL Encoding

Data in a URL goes after ? as name=value pairs joined by &. Special characters must be percent-encoded.

import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;

public class QueryStringDemo {
    public static void main(String[] args) {
        String encoded = URLEncoder.encode("Java & Spring", StandardCharsets.UTF_8);
        System.out.println("Encoded: " + encoded);

        String query = "course=" + encoded + "&level=beginner";
        System.out.println("Query:   " + query);
        System.out.println("Parsed:  " + parseQuery(query));
    }

    static Map<String, String> parseQuery(String query) {
        Map<String, String> params = new LinkedHashMap<>();
        for (String pair : query.split("&")) {
            String[] parts = pair.split("=", 2);
            String name = URLDecoder.decode(parts[0], StandardCharsets.UTF_8);
            String value = parts.length > 1 ? URLDecoder.decode(parts[1], StandardCharsets.UTF_8) : "";
            params.put(name, value);
        }
        return params;
    }
}

Output:

Encoded: Java+%26+Spring
Query:   course=Java+%26+Spring&level=beginner
Parsed:  {course=Java & Spring, level=beginner}

How it works:

  • URLEncoder turns & into %26 and spaces into +, so the value cannot be confused with the separators.
  • URLDecoder reverses this. Servlets do this parsing for you through request.getParameter(...), as shown in HttpServletRequest in Java.

Request Bodies and Content-Type

POST, PUT and PATCH usually send data in the body. The Content-Type header tells the server how to read it.

Content-TypeBody looks likeTypical sender
application/x-www-form-urlencodedname=Asha&course=JavaHTML forms
multipart/form-dataParts separated by a boundaryForms with file uploads
application/json{"name":"Asha"}JavaScript and API clients
text/plainAny textSimple tools
server.createContext("/submit", exchange -> {
    String contentType = exchange.getRequestHeaders().getFirst("Content-Type");
    String body = new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);

    String reply = "Type: " + contentType + "\nBody: " + body + "\n";
    byte[] bytes = reply.getBytes(StandardCharsets.UTF_8);
    exchange.sendResponseHeaders(200, bytes.length);
    try (OutputStream out = exchange.getResponseBody()) { out.write(bytes); }
});
curl -d "name=Asha&course=Java" http://localhost:8000/submit
curl -H "Content-Type: application/json" -d '{"name":"Ravi"}' http://localhost:8000/submit

Output:

Type: application/x-www-form-urlencoded
Body: name=Asha&course=Java
Type: application/json
Body: {"name":"Ravi"}

How it works:

  • curl -d sends a POST with a form-encoded body by default. Adding -H "Content-Type: ..." changes the declared type.
  • getRequestBody() returns an InputStream. readAllBytes() reads the whole body, which is fine for small requests.

Cookies and Stateless HTTP

HTTP is stateless: each request stands alone, and the server does not remember the previous one. Cookies add memory. The server sends Set-Cookie, and the client returns the value in a Cookie header on later requests.

server.createContext("/visits", exchange -> {
    int visits = 0;
    String cookieHeader = exchange.getRequestHeaders().getFirst("Cookie");
    if (cookieHeader != null) {
        for (String cookie : cookieHeader.split(";\\s*")) {
            if (cookie.startsWith("visits=")) {
                visits = Integer.parseInt(cookie.substring("visits=".length()));
            }
        }
    }
    visits++;

    exchange.getResponseHeaders().add("Set-Cookie", "visits=" + visits + "; Path=/; HttpOnly");
    byte[] bytes = ("Visit number " + visits + "\n").getBytes(StandardCharsets.UTF_8);
    exchange.sendResponseHeaders(200, bytes.length);
    try (OutputStream out = exchange.getResponseBody()) { out.write(bytes); }
});
// VisitClient.java: the CookieManager stores and resends cookies like a browser
import java.net.CookieManager;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class VisitClient {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder().cookieHandler(new CookieManager()).build();
        HttpRequest request = HttpRequest.newBuilder(URI.create("http://localhost:8000/visits")).build();
        for (int i = 0; i < 3; i++) {
            System.out.print(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
        }
    }
}

Output:

Visit number 1
Visit number 2
Visit number 3

How it works:

  • The first request has no cookie, so the count starts at 1 and the server sets visits=1.
  • CookieManager saves the cookie and adds Cookie: visits=1 to the next request, and so on. Without it, every call would print "Visit number 1".
  • HttpOnly stops JavaScript in a browser from reading the cookie. Servlets build sessions on this same mechanism with a JSESSIONID cookie.

Real-World Example: HTTP Basics in Java With a Small Student API

This server combines methods, status codes, headers, query strings and JSON bodies into a small REST-style API. It returns 201 Created with a Location header for new students and 405 with an Allow header for unsupported methods.

// StudentApiServer.java
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class StudentApiServer {

    private static final Map<Integer, String> students = new ConcurrentHashMap<>();
    private static final AtomicInteger nextId = new AtomicInteger(1);
    private static final Pattern NAME_FIELD = Pattern.compile("\"name\"\\s*:\\s*\"([^\"]+)\"");

    public static void main(String[] args) throws IOException {
        students.put(nextId.getAndIncrement(), "Asha");
        students.put(nextId.getAndIncrement(), "Ravi");

        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/students", StudentApiServer::handleStudents);
        server.setExecutor(Executors.newFixedThreadPool(4));   // handle 4 requests at once
        server.start();
        System.out.println("Student API on http://localhost:8000/students");
    }

    private static void handleStudents(HttpExchange exchange) throws IOException {
        switch (exchange.getRequestMethod()) {
            case "GET" -> listOrFind(exchange);
            case "POST" -> create(exchange);
            default -> {
                exchange.getResponseHeaders().set("Allow", "GET, POST");
                sendJson(exchange, 405, "{\"error\":\"Method not allowed\"}");
            }
        }
    }

    private static void listOrFind(HttpExchange exchange) throws IOException {
        String query = exchange.getRequestURI().getQuery();      // e.g. "id=2" or null
        if (query != null && query.startsWith("id=")) {
            int id = Integer.parseInt(query.substring(3));
            String name = students.get(id);
            if (name == null) {
                sendJson(exchange, 404, "{\"error\":\"Student " + id + " not found\"}");
            } else {
                sendJson(exchange, 200, toJson(id, name));
            }
            return;
        }
        String all = students.entrySet().stream()
                .map(entry -> toJson(entry.getKey(), entry.getValue()))
                .collect(Collectors.joining(",", "[", "]"));
        sendJson(exchange, 200, all);
    }

    private static void create(HttpExchange exchange) throws IOException {
        String body = new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);
        Matcher matcher = NAME_FIELD.matcher(body);
        if (!matcher.find()) {
            sendJson(exchange, 400, "{\"error\":\"Body must contain a name\"}");
            return;
        }
        int id = nextId.getAndIncrement();
        students.put(id, matcher.group(1));
        exchange.getResponseHeaders().set("Location", "/students?id=" + id);
        sendJson(exchange, 201, toJson(id, matcher.group(1)));
    }

    private static String toJson(int id, String name) {
        return "{\"id\":" + id + ",\"name\":\"" + name + "\"}";
    }

    private static void sendJson(HttpExchange exchange, int status, String json) throws IOException {
        byte[] bytes = (json + "\n").getBytes(StandardCharsets.UTF_8);
        exchange.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
        exchange.sendResponseHeaders(status, bytes.length);
        try (OutputStream out = exchange.getResponseBody()) {
            out.write(bytes);
        }
    }
}

Try every path with curl:

java StudentApiServer.java
curl -s http://localhost:8000/students
curl -s "http://localhost:8000/students?id=2"
curl -s -i -X POST -H "Content-Type: application/json" -d '{"name":"Meena"}' http://localhost:8000/students
curl -s -w " (%{http_code})\n" "http://localhost:8000/students?id=9"
curl -s -w " (%{http_code})\n" -d '{}' http://localhost:8000/students
curl -s -i -X DELETE http://localhost:8000/students | head -n 1

Output (Date headers removed):

[{"id":1,"name":"Asha"},{"id":2,"name":"Ravi"}]
{"id":2,"name":"Ravi"}
HTTP/1.1 201 Created
Location: /students?id=3
Content-type: application/json; charset=utf-8
Content-length: 24

{"id":3,"name":"Meena"}
{"error":"Student 9 not found"}
 (404)
{"error":"Body must contain a name"}
 (400)
HTTP/1.1 405 Method Not Allowed

How it works:

  1. One path, several methods. /students supports GET for reading and POST for creating. Any other method gets 405 plus an Allow header that lists the valid ones.
  2. Correct status codes. A missing student returns 404, a bad body returns 400, and a new student returns 201 Created with a Location header that points to it.
  3. Query string lookup. getRequestURI().getQuery() returns the text after ?, which selects a single student.
  4. Thread-safe data. setExecutor gives the server a pool of four threads, so requests can run at the same time. The data therefore lives in a ConcurrentHashMap and IDs come from an AtomicInteger.
  5. JSON responses. Every reply sets Content-Type: application/json, so clients know how to read the body. In the next lesson, Java Servlet Basics, the same ideas run inside Tomcat, which parses parameters and manages threads for you.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about HTTP Basics in Java and get answers drawn from it.

Signed-in readers only.