Content Handlers & Output Formats

import java.io.IOException;
import java.nio.file.Path;
import org.apache.tika.exception.TikaException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BasicContentHandlerFactory;
import org.apache.tika.sax.BasicContentHandlerFactory.HANDLER_TYPE;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

public class AllFormats {

    public static void main(String[] args) throws IOException, SAXException, TikaException {
        AutoDetectParser parser = new AutoDetectParser();
        Path file = Path.of("manuscript.docx");

        for (HANDLER_TYPE type : HANDLER_TYPE.values()) {
            // -1: no write limit. A fresh handler per parse: handlers are single use.
            ContentHandler handler = new BasicContentHandlerFactory(type, -1).createHandler();
            try (TikaInputStream in = TikaInputStream.get(file)) {
                parser.parse(in, handler, new Metadata(), new ParseContext());
            }
            System.out.println("===== " + type + " (" + handler.getClass().getSimpleName() + ")");
            System.out.println(handler);
        }
    }
}

import java.io.IOException;
import java.nio.file.Path;
import org.apache.tika.exception.TikaException;
import org.apache.tika.exception.WriteLimitReachedException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BasicContentHandlerFactory;
import org.apache.tika.sax.BasicContentHandlerFactory.HANDLER_TYPE;
import org.apache.tika.sax.BodyContentHandler;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

public class Limits {

    public static void main(String[] args) throws IOException, TikaException, SAXException {
        AutoDetectParser parser = new AutoDetectParser();
        Path big = Path.of("long-manuscript.txt");   // about 150,000 characters

        // 1. Default BodyContentHandler: 100,000 characters, then an exception
        BodyContentHandler body = new BodyContentHandler();
        try (TikaInputStream in = TikaInputStream.get(big)) {
            parser.parse(in, body, new Metadata(), new ParseContext());
        } catch (SAXException e) {
            if (WriteLimitReachedException.isWriteLimitReached(e)) {
                System.out.println("limit reached, partial text kept: " + body.toString().length());
            } else {
                throw e;
            }
        }

        // 2. -1 disables the limit
        BodyContentHandler unlimited = new BodyContentHandler(-1);
        try (TikaInputStream in = TikaInputStream.get(big)) {
            parser.parse(in, unlimited, new Metadata(), new ParseContext());
        }
        System.out.println("unlimited: " + unlimited.toString().length());

        // 3. A factory that truncates silently and reports it in the metadata
        ParseContext context = new ParseContext();
        ContentHandler quiet = new BasicContentHandlerFactory(HANDLER_TYPE.TEXT, 1000, false, context)
                .createHandler();
        Metadata metadata = new Metadata();
        try (TikaInputStream in = TikaInputStream.get(big)) {
            parser.parse(in, quiet, metadata, context);
        }
        System.out.println("truncated to " + quiet.toString().length() + " characters, flag: "
                + metadata.get("tk:exception:write-limit-reached"));
    }
}

limit reached, partial text kept: 100000
unlimited: 150001
truncated to 1000 characters, flag: true

import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import org.apache.tika.exception.TikaException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BasicContentHandlerFactory;
import org.apache.tika.sax.BasicContentHandlerFactory.HANDLER_TYPE;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

public class StreamToFile {

    public static void main(String[] args) throws IOException, SAXException, TikaException {
        BasicContentHandlerFactory factory = new BasicContentHandlerFactory(HANDLER_TYPE.MARKDOWN, -1);
        Path target = Path.of("manuscript.md");

        try (OutputStream out = Files.newOutputStream(target);
             TikaInputStream in = TikaInputStream.get(Path.of("manuscript.docx"))) {
            // The handler writes to the stream as the parser emits events; nothing is buffered as a String.
            ContentHandler handler = factory.createHandler(out, StandardCharsets.UTF_8);
            new AutoDetectParser().parse(in, handler, new Metadata(), new ParseContext());
        }

        System.out.println(Files.size(target) + " bytes written to " + target);
    }
}

343 bytes written to manuscript.md

import java.io.IOException;
import java.io.Reader;
import java.nio.file.Path;
import org.apache.tika.parser.ParsingReader;

public class ReaderDemo {

    public static void main(String[] args) throws IOException {
        try (Reader reader = new ParsingReader(Path.of("manuscript.docx"))) {
            char[] buffer = new char[60];
            int n = reader.read(buffer);
            System.out.println(new String(buffer, 0, n).replace("\n", "\\n"));
        }
    }
}

The Lighthouse Keeper\nA short novel by Ana Torres.\nThe keepe

import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import org.apache.tika.exception.TikaException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BodyContentHandler;
import org.apache.tika.sax.LinkContentHandler;
import org.apache.tika.sax.TeeContentHandler;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class Headings {

    /** Collects "h1: text" lines for every heading element in the XHTML stream. */
    static class HeadingCollector extends DefaultHandler {
        final List<String> headings = new ArrayList<>();
        private String current;
        private final StringBuilder text = new StringBuilder();

        @Override
        public void startElement(String uri, String local, String qName, Attributes atts) {
            if (local.matches("h[1-6]")) {
                current = local;
                text.setLength(0);
            }
        }

        @Override
        public void characters(char[] ch, int start, int length) {
            if (current != null) {
                text.append(ch, start, length);
            }
        }

        @Override
        public void endElement(String uri, String local, String qName) {
            if (local.equals(current)) {
                headings.add(current + ": " + text);
                current = null;
            }
        }
    }

    public static void main(String[] args) throws IOException, SAXException, TikaException {
        HeadingCollector headings = new HeadingCollector();
        LinkContentHandler links = new LinkContentHandler();
        BodyContentHandler body = new BodyContentHandler(-1);

        try (TikaInputStream in = TikaInputStream.get(Path.of("manuscript.docx"))) {
            new AutoDetectParser().parse(in, new TeeContentHandler(headings, links, body),
                    new Metadata(), new ParseContext());
        }

        headings.headings.forEach(System.out::println);
        links.getLinks().forEach(l -> System.out.println(l.getUri() + " -> \"" + l.getText() + "\""));
        System.out.println("body characters: " + body.toString().length());
    }
}

h1: The Lighthouse Keeper
h2: Themes
https://example.org/bookshelf/lighthouse -> "the Bookshelf page"
https://example.org/bookshelf/lighthouse -> ""
body characters: 198

<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-handler-boilerpipe</artifactId>
    <version>4.1.0</version>
</dependency>

import java.io.IOException;
import java.io.StringWriter;
import java.nio.file.Path;
import org.apache.tika.exception.TikaException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BodyContentHandler;
import org.apache.tika.sax.boilerpipe.BoilerpipeContentHandler;
import org.xml.sax.SAXException;

public class MainContent {

    public static void main(String[] args) throws IOException, SAXException, TikaException {
        StringWriter main = new StringWriter();
        try (TikaInputStream in = TikaInputStream.get(Path.of("reviews-es.html"))) {
            new AutoDetectParser().parse(in, new BoilerpipeContentHandler(main), new Metadata(),
                    new ParseContext());
        }
        System.out.println(main);

        StringWriter all = new StringWriter();
        try (TikaInputStream in = TikaInputStream.get(Path.of("reviews-es.html"))) {
            new AutoDetectParser().parse(in, new BodyContentHandler(all), new Metadata(),
                    new ParseContext());
        }
        System.out.println(all);
    }
}

Spring reading listThe Lighthouse Keeper reviewed
The Lighthouse Keeper is a slow and luminous novel. Ana Torres builds a small, almost domestic world where the keeper
counts the waves every night and waits for a letter that never arrives.
The pocket edition can be read over a weekend, although the typeface is a little small. Recommended to anyone who
enjoys quiet reading by the window.
Copyright Bookshelf. Terms. Privacy. Contact us.

import java.io.IOException;
import java.nio.file.Path;
import org.apache.tika.exception.TikaException;
import org.apache.tika.io.TikaInputStream;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.SAXOutputConfig;
import org.apache.tika.sax.ToXMLContentHandler;
import org.xml.sax.SAXException;

public class OutputConfig {

    public static void main(String[] args) throws IOException, SAXException, TikaException {
        SAXOutputConfig config = new SAXOutputConfig();
        config.setWriteMetadataToHead(false);   // no meta elements in the head
        config.setIncludeTitle(false);          // no title element either

        ParseContext context = new ParseContext();
        context.set(SAXOutputConfig.class, config);

        ToXMLContentHandler xhtml = new ToXMLContentHandler();
        try (TikaInputStream in = TikaInputStream.get(Path.of("manuscript.docx"))) {
            new AutoDetectParser().parse(in, xhtml, new Metadata(), context);
        }
        System.out.println(xhtml.toString().lines().limit(4).toList());
    }
}

[<html xmlns="http://www.w3.org/1999/xhtml">, <head>, </head>, <body><h1>The Lighthouse Keeper</h1>]