I'm not a professional Go programmer so feel free to correct me on anything.
The rest of this post is going to follow the example program from this piece of Go Documentation. I'm even going to straight rip a lot of the prose.
My intent is to highlight how you can do spiritually similar things in Java.
The code in this guide, god willing, will work unaltered in Java 25.
Make a new directory for this tutorial and cd into it:
$ mkdir javawiki
$ cd javawikiCreate a file named Wiki.java, open it in your favorite editor, and add the following lines:
void main() {
}A wiki consists of a series of interconnected pages, each of which has a title and a body (the page content). Here, we define Page as a record with two components representing the title and body.
record Page(String title, byte[] body) {}The Page record describes how page data will be stored in memory. But what about persistent storage? We can address that by creating a save method on Page:
record Page(String title, byte[] body) {
void save() throws IOException {
var filename = title + ".txt";
Files.write(Path.of(filename), body);
}
}The save method throws an IOException to let the application handle it should anything go wrong while writing the file. If all goes well, Page.save() will return without throwing.
In addition to saving pages, we will want to load pages, too:
record Page(String title, byte[] body) {
void save() throws IOException {
var filename = title + ".txt";
Files.write(Path.of(filename), body);
}
static Page load(String title) throws IOException {
var filename = title + ".txt";
var body = Files.readAllBytes(Path.of(filename));
return new Page(title, body);
}
}The method load constructs the file name from the title parameter, reads the file's contents into a new variable body, and returns a reference to a Page object.
At this point we have a simple data structure and the ability to save to and load from a file. Let's update the main method to test what we've written:
void main() throws IOException {
var p1 = new Page(
"TestPage",
"This is a sample Page.".getBytes(StandardCharsets.UTF_8)
);
p1.save();
var p2 = Page.load("TestPage");
IO.println(new String(p2.body, StandardCharsets.UTF_8));
}After executing this code, a file named TestPage.txt would be created, containing the contents of p1. The file would then be read into p2, and its body component printed to the screen.
You can run the program like this:
$ java Wiki.javaClick here to view the code we've written so far.
Here's a full working example of a simple web server:
import module jdk.httpserver;
void handler(HttpExchange exchange) throws IOException {
exchange.sendResponseHeaders(200, 0);
try (var os = exchange.getResponseBody()) {
os.write(
"Hi there, I love %s!"
.formatted(exchange.getRequestURI().getPath().substring(1))
.getBytes(StandardCharsets.UTF_8)
);
}
}
void main() throws IOException {
var server = HttpServer.create(
new InetSocketAddress(8080),
0
);
server.createContext("/", this::handler);
server.start();
}The main method begins with a call to HttpServer.create, which creates an http server that will listen on port 8080. (Don't worry about its second parameter, 0, for now.)
Then server.createContext tells the server to handle all requests to the web root ("/") with handler.
It then calls `server.start(). This method will block until the program is terminated.
If you run this program and access the URL:
http://localhost:8080/monkeysthe program would present a page containing:
Hi there, I love monkeys!The jdk.httpserver module does not see as widespread use as Go's equivalent. As such, I think there are some ways to improve the API that should be rolled into the standard library at some point.
I put the most important of these - a Body abstraction - into a library. I'm going to ignore how to procure libraries in Java for the moment, but suspend your disbelief in the meantime.
With this library the server example above becomes the following:
import module jdk.httpserver;
import module dev.mccue.jdk.httpserver;
void handler(HttpExchange exchange) throws IOException {
HttpExchanges.sendResponse(
exchange,
200,
Body.of("Hi there, I love %s!".formatted(
exchange.getRequestURI().getPath().substring(1)
))
);
}
void main() throws IOException {
var server = HttpServer.create(
new InetSocketAddress(8080),
0
);
server.createContext("/", this::handler);
server.start();
}Let's create a handler, viewHandler that will allow users to view a wiki page. It will handle URLs prefixed with "/view/".
void viewHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/view/".length());
var p = Page.load(title);
HttpExchanges.sendResponse(
exchange,
200,
Body.of(
"<h1>%s</h1><div>%s</div>"
.formatted(
p.title,
new String(p.body, StandardCharsets.UTF_8)
)
)
);
}To use this handler, we rewrite our main function to initialize an HttpServer using the viewHandler to handle any requests under the path /view/.
void main() throws IOException {
var server = HttpServer.create(
new InetSocketAddress(8080),
0
);
server.createContext("/view/", this::viewHandler);
server.start();
}Click here to view the code we've written so far.
Let's create some page data (as test.txt), compile our code, and try serving a wiki page.
Open test.txt file in your editor, and save the string "Hello world" (without quotes) in it.
java --module-path lib --add-modules ALL-MODULE-PATH Wiki.javaWith this web server running, a visit to http://localhost:8080/view/test should show a page titled "test" containing the words "Hello world".
A wiki is not a wiki without the ability to edit pages. Let's create two new handlers: one named editHandler to display an 'edit page' form, and the other named saveHandler to save the data entered via the form.
First, we add them to main():
void main() throws IOException {
var server = HttpServer.create(
new InetSocketAddress(8700),
0
);
server.createContext("/view/", this::viewHandler);
server.createContext("/edit/", this::editHandler);
server.createContext("/save/", this::saveHandler);
server.start();
}The method editHandler loads the page (or, if it doesn't exist, create an empty Page record), and displays an HTML form.
void editHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/edit/".length());
Page p;
try {
p = Page.load(title);
} catch (NoSuchFileException e) {
p = new Page(title, new byte[]{});
}
HttpExchanges.sendResponse(
exchange,
200,
Body.of(
"""
<h1>Editing %s</h1>
<form action="/save/%s" method="POST">
<textarea name="body">%s</textarea><br>
<input type="submit" value="Save">
</form>
""".formatted(
p.title,
p.title,
new String(p.body, StandardCharsets.UTF_8)
)
)
);
}This function will work fine, but all that hard-coded HTML is ugly. Of course, there is a better way.
(I mean honestly the bigger issue is XSS vulnerabilities, but whatever. Following along.)
com.samskivert.jmustache is a library available in the Java ecosystem. We can use it to keep the HTML in a separate file, allowing us to change the layout of our edit page without modifying the underlying Java code.
First, we must add com.samskivert.jmustache to the list of imports. Again, we are glancing over how you procure libraries for this tutorial.
import module jdk.httpserver;
import module dev.mccue.jdk.httpserver;
import module com.samskivert.jmustache;Let's create a template file containing the HTML form. Open a new file named edit.html, and add the following lines:
<h1>Editing {{title}}</h1>
<form action="/save/{{title}}" method="POST">
<div><textarea name="body" rows="20" cols="80">{{body}}</textarea></div>
<div><input type="submit" value="Save"></div>
</form>Modify editHandler to use the template, instead of the hard-coded HTML:
void editHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/edit/".length());
Page p;
try {
p = Page.load(title);
} catch (NoSuchFileException e) {
p = new Page(title, new byte[]{});
}
var template = Mustache.compiler()
.compile(Files.readString(Path.of("edit.html")));
HttpExchanges.sendResponse(
exchange,
200,
Body.of(template.execute(Map.of(
"title", p.title,
"body", new String(p.body, StandardCharsets.UTF_8)
)))
);
}Since we're working with templates now, let's create a template for our viewHandler called view.html:
<h1>{{title}}</h1>
<p>[<a href="/edit/{{title}}">edit</a>]</p>
<div>{{body}}</div>Modify viewHandler accordingly:
void viewHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/view/".length());
var p = Page.load(title);
var template = Mustache.compiler()
.compile(Files.readString(Path.of("view.html")));
HttpExchanges.sendResponse(
exchange,
200,
Body.of(template.execute(Map.of(
"title", p.title,
"body", new String(p.body, StandardCharsets.UTF_8)
)))
);
}Notice that we've used almost exactly the same templating code in both handlers. Let's remove this duplication by moving the templating code to its own function:
void renderTemplate(
HttpExchange exchange,
String tmpl,
Page p
) throws IOException {
var template = Mustache.compiler()
.compile(Files.readString(Path.of(tmpl)));
HttpExchanges.sendResponse(
exchange,
200,
Body.of(template.execute(Map.of(
"title", p.title,
"body", new String(p.body, StandardCharsets.UTF_8)
)))
);
}And modify the handlers to use that function:
void viewHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/view/".length());
var p = Page.load(title);
renderTemplate(exchange, "view", p);
}
void editHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/edit/".length());
Page p;
try {
p = Page.load(title);
} catch (NoSuchFileException e) {
p = new Page(title, new byte[]{});
}
renderTemplate(exchange, "edit", p);
}Click here to view the code we've written so far.
What if you visit /view/APageThatDoesntExist You'll get no response. This is because Page.load errors. Instead, if the requested Page doesn't exist, it should redirect the client to the edit Page so the content may be created:
void viewHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/view/".length());
Page p;
try {
p = Page.load(title);
} catch (NoSuchFileException _) {
exchange.getResponseHeaders()
.put("Location", List.of("/edit/" + title));
HttpExchanges.sendResponse(exchange, 302, Body.empty());
return;
}
renderTemplate(exchange, "view", p);
}To do this we send an HTTP status code of 302 and a include Location header in the response.
The function saveHandler will handle the submission of forms located on the edit pages. To parse the form body we are going to add another library - dev.mccue.urlparameters.
import module dev.mccue.urlparameters;void saveHandler(HttpExchange exchange) throws IOException {
var title = exchange.getRequestURI()
.getPath()
.substring("/save/".length());
var body = UrlParameters.parse(
new String(
exchange.getRequestBody().readAllBytes(),
StandardCharsets.UTF_8
)
).firstValue("body").orElseThrow();
var p = new Page(title, body.getBytes(StandardCharsets.UTF_8));
p.save();
exchange.getResponseHeaders()
.put("Location", List.of("/view/" + title));
HttpExchanges.sendResponse(exchange, 302, Body.empty());
}Click here to view the code we've written so far.
There is more in the Go tutorial, including caching templates, making sure there aren't path traversal vulnerabilities (which, very important!), and some other potpourri.
But the purpose of this is just to illustrate that Java is capable of the same sort of "simple" web development that Go is known for. I'm leaving that stuff (and introducing a proper mux) as exercises for you the reader.
And just as a note: If you dig into the jdk.httpserver module you will see some "for development only" warnings around it. This is because the actual server implementation in the JDK is mostly there to serve the jwebserver tool. (jwebserver is more or less equivalent to Python's http.server) You can seamlessly swap to using a production quality server like Jetty and others by adding the appropriate dependencies.
Tell me all about your past traumas with Java in the comments below.