java 64 lines · 8 steps

Parsing multipart form data by hand in Java

A byte-level parser that splits a multipart/form-data body on its boundary and extracts each uploaded file.

Explained by highlit

Advanced parsing byte-arrays http state-machine string-search

1public final class MultipartParser {
2 
  public record FilePart(String name, String filename, String contentType, byte[] content) {}
4 
  private final byte[] data;
  private final byte[] boundary;
7 
  public MultipartParser(byte[] data, String contentType) {
      this.data = data;
      String marker = "boundary=";
      int i = contentType.indexOf(marker);
      if (i < 0) throw new IllegalArgumentException("missing boundary");
      String b = contentType.substring(i + marker.length()).trim();
      if (b.startsWith("\"")) b = b.substring(1, b.length() - 1);
      this.boundary = ("--" + b).getBytes(StandardCharsets.ISO_8859_1);
  }
17 
  public List<FilePart> parse() {
      List<FilePart> parts = new ArrayList<>();
      int pos = indexOf(boundary, 0);
      while (pos >= 0) {
          int start = pos + boundary.length;
          if (start + 2 <= data.length && data[start] == '-' && data[start + 1] == '-') break;
          start += 2;
          int headerEnd = indexOf("\r\n\r\n".getBytes(StandardCharsets.ISO_8859_1), start);
          if (headerEnd < 0) break;
          String headers = new String(data, start, headerEnd - start, StandardCharsets.ISO_8859_1);
          int bodyStart = headerEnd + 4;
          int next = indexOf(boundary, bodyStart);
          int bodyEnd = next - 2;
          FilePart part = buildPart(headers, Arrays.copyOfRange(data, bodyStart, bodyEnd));
          if (part != null) parts.add(part);
          pos = next;
      }
      return parts;
  }
37 
  private FilePart buildPart(String headers, byte[] body) {
      String name = extract(headers, "name=\"", "\"");
      String filename = extract(headers, "filename=\"", "\"");
      if (filename == null) return null;
      String type = extract(headers, "Content-Type: ", "\r\n");
      return new FilePart(name, filename, type != null ? type.trim() : "application/octet-stream", body);
  }
45 
  private String extract(String source, String prefix, String suffix) {
      int i = source.indexOf(prefix);
      if (i < 0) return null;
      i += prefix.length();
      int j = source.indexOf(suffix, i);
      return j < 0 ? source.substring(i) : source.substring(i, j);
  }
53 
  private int indexOf(byte[] needle, int from) {
      outer:
      for (int i = from; i <= data.length - needle.length; i++) {
          for (int j = 0; j < needle.length; j++) {
              if (data[i + j] != needle[j]) continue outer;
          }
          return i;
      }
      return -1;
  }
64}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Multipart bodies must be scanned as raw bytes, not decoded strings, so file content survives intact.
2The boundary from the Content-Type header is the delimiter that separates every part in the body.
3Splitting a format into locate-header, extract-metadata, and copy-body phases keeps a hand-rolled parser manageable.

Related explainers

ruby

class UserAgentParser
  BROWSERS = [
    [/Edg\/([\d.]+)/, "Edge"],
    [/OPR\/([\d.]+)/, "Opera"],

Parsing user-agent strings in Ruby

regex pattern-matching lookup-tables

Intermediate 8 steps

java

@Component
@Converter
public class EncryptedStringConverter implements AttributeConverter<String, String> {

Transparent column encryption in Spring & JPA

encryption aes-gcm jpa-converter

Advanced 10 steps

javascript

function evaluate(expression) {
  const tokens = tokenize(expression);
  let pos = 0;

Building a recursive descent calculator

parsing recursion operator-precedence

Intermediate 8 steps

java

package com.acme.billing.config;
 
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;

Feature-flagged beans with Spring @ConditionalOnProperty

feature-flags conditional-beans strategy-pattern

Intermediate 5 steps

rust

use chrono::{Duration, NaiveDate};
 
#[derive(Debug)]
pub struct DateRange {

Parsing and iterating date ranges in Rust

error-handling iterators parsing

Intermediate 7 steps

java

public static Map<String, String> parseCookieHeader(String header) {
    Map<String, String> cookies = new LinkedHashMap<>();
    if (header == null || header.isBlank()) {
        return cookies;