Innholdsanalyse med Apache Tika

1. Oversikt

Apache Tika er et verktøysett for å trekke ut innhold og metadata fra forskjellige typer dokumenter, for eksempel Word, Excel og PDF, eller til og med multimediefiler som JPEG og MP4.

Alle tekstbaserte filer og multimediafiler kan analyseres ved hjelp av et felles grensesnitt, noe som gjør Tika til et kraftig og allsidig bibliotek for innholdsanalyse.

I denne artikkelen vil vi gi en introduksjon til Apache Tika, inkludert dens parsing API og hvordan den automatisk oppdager innholdstypen til et dokument. Arbeidseksempler vil også bli gitt for å illustrere driften av dette biblioteket.

2. Komme i gang

For å analysere dokumenter ved hjelp av Apache Tika, trenger vi bare en Maven-avhengighet:

 org.apache.tika tika-parsers 1.17

Den siste versjonen av denne gjenstanden finner du her.

**3. Den Parser API**

De Parser API er hjertet til Apache Tika, og tar bort kompleksiteten i parseringsoperasjonene. Dette API er avhengig av en enkelt metode:

void parse (InputStream stream, ContentHandler handler, Metadata metadata, ParseContext context) kaster IOException, SAXException, TikaException

Betydningen av parametrene til denne metoden er:

strøm – en InputStream forekomst opprettet fra dokumentet som skal analyseres
behandler – en ContentHandler objekt som mottar en sekvens av XHTML SAX-hendelser analysert fra inngangsdokumentet; denne behandleren vil deretter behandle hendelser og eksportere resultatet i en bestemt form
metadata – en Metadata objekt som formidler metadataegenskaper inn og ut av parseren
kontekst – en ParseContext forekomst med kontekstspesifikk informasjon, brukt til å tilpasse analyseprosessen

De analysere metoden kaster en IO Unntak hvis den ikke leser fra inngangsstrømmen, a Tika Unntak hvis dokumentet hentet fra strømmen ikke kan analyseres og a SAXException hvis behandleren ikke er i stand til å behandle en hendelse.

Når du analyserer et dokument, prøver Tika å gjenbruke eksisterende parserbiblioteker som Apache POI eller PDFBox så mye som mulig. Som et resultat, mesteparten av Parser implementeringsklasser er bare adaptere til slike eksterne biblioteker.

I avsnitt 5 vil vi se hvordan behandler og metadata parametere kan brukes til å trekke ut innhold og metadata i et dokument.

For enkelhets skyld kan vi bruke fasadeklassen Tika for å få tilgang til funksjonaliteten til Parser API.

4. Autodeteksjon

Apache Tika kan automatisk oppdage typen av dokument og dets språk basert på selve dokumentet i stedet for på tilleggsinformasjon.

4.1. Dokumenttypegjenkjenning

Påvisning av dokumenttyper kan gjøres ved hjelp av en implementeringsklasse for Detektor grensesnitt, som har en enkelt metode:

MediaType-deteksjon (java.io.InputStream-inngang, metadata-metadata) kaster IOException

Denne metoden tar et dokument, og dets tilknyttede metadata - og returnerer deretter en Media type objekt som beskriver den beste gjetningen angående dokumenttypen.

Metadata er ikke den eneste informasjonskilden som en detektor er avhengig av. Detektoren kan også bruke magiske byte, som er et spesielt mønster nær begynnelsen av en fil eller delegere deteksjonsprosessen til en mer passende detektor.

Faktisk er algoritmen som detektoren bruker, avhengig av implementering.

For eksempel fungerer standarddetektoren først med magiske byte, deretter metadataegenskaper. Hvis innholdstypen ikke ble funnet på dette tidspunktet, vil den bruke tjenestelaster for å oppdage alle tilgjengelige detektorer og prøve dem på sin side.

4.2. Språkoppdagelse

I tillegg til dokumenttypen, kan Tika også identifisere språket selv uten hjelp fra metadatainformasjon.

I tidligere utgivelser av Tika oppdages språket i dokumentet ved hjelp av a LanguageIdentifier forekomst.

Derimot, LanguageIdentifier er utfaset til fordel for webtjenester, noe som ikke er tydeliggjort i Komme i gang-dokumentene.

Språkoppdagelsestjenester tilbys nå via undertyper av abstraktklassen LanguageDetector. Ved hjelp av webtjenester kan du også få tilgang til fullverdige online oversettelsestjenester, for eksempel Google Translate eller Microsoft Translator.

For korthets skyld vil vi ikke gå gjennom disse tjenestene i detalj.

5. Tika i aksjon

Denne delen illustrerer Apache Tika-funksjoner ved hjelp av arbeidseksempler.

Illustrasjonsmetodene blir pakket inn i en klasse:

offentlig klasse TikaAnalysis {// illustrasjonsmetoder}

5.1. Oppdage dokumenttyper

Her er koden vi kan bruke til å oppdage hvilken type dokument som er lest fra en InputStream:

public static String detectDocTypeUsingDetector (InputStream stream) kaster IOException {Detector detector = new DefaultDetector (); Metadata metadata = nye metadata (); MediaType mediaType = detector.detect (stream, metadata); returner mediaType.toString (); }

Anta at vi har en PDF-fil som heter tika.txt i klassestien. Forlengelsen av denne filen er endret for å prøve å lure analyseverktøyet vårt. Den virkelige typen dokument kan fremdeles bli funnet og bekreftet av en test:

@Test offentlig ugyldig nårUsingDetector_thenDocumentTypeIsReturned () kaster IOException {InputStream stream = this.getClass (). GetClassLoader () .getResourceAsStream ("tika.txt"); String mediaType = TikaAnalysis.detectDocTypeUsingDetector (stream); assertEquals ("application / pdf", mediaType); stream.close (); }

Det er klart at en feil filtype ikke kan forhindre Tika i å finne riktig medietype, takket være de magiske bytene % PDF i starten av filen.

For enkelhets skyld kan vi skrive om deteksjonskoden på nytt med Tika fasadeklasse med samme resultat:

public static String detectDocTypeUsingFacade (InputStream stream) kaster IOException {Tika tika = new Tika (); String mediaType = tika.detect (stream); returner mediaType; }

5.2. Pakke ut innhold

La oss nå trekke ut innholdet i en fil og returnere resultatet som en String - bruker Parser API:

offentlig statisk strengutdragContentUsingParser (InputStream stream) kaster IOException, TikaException, SAXException {Parser parser = ny AutoDetectParser (); ContentHandler handler = ny BodyContentHandler (); Metadata metadata = nye metadata (); ParseContext context = ny ParseContext (); parser.parse (stream, handler, metadata, kontekst); retur handler.toString (); }

Gitt en Microsoft Word-fil i klassestien med dette innholdet:

Apache Tika - et verktøy for innholdsanalyse Apache Tika ™ -verktøysettet oppdager og trekker ut metadata og tekst ...

Innholdet kan trekkes ut og bekreftes:

@Test offentlig ugyldig nårUsingParser_thenContentIsReturned () kaster IOException, TikaException, SAXException {InputStream stream = this.getClass (). GetClassLoader () .getResourceAsStream ("tika.docx"); Strenginnhold = TikaAnalysis.extractContentUsingParser (stream); assertThat (content, containString ("Apache Tika - et verktøy for innholdsanalyse")); assertThat (innhold, inneholderString ("oppdager og trekker ut metadata og tekst")); stream.close (); }

Igjen, den Tika klasse kan brukes til å skrive koden lettere:

offentlig statisk strengutdragContentUsingFacade (InputStream stream) kaster IOException, TikaException {Tika tika = ny Tika (); Strenginnhold = tika.parseToString (stream); returnere innhold; }

5.3. Henter ut metadata

I tillegg til innholdet i et dokument, har Parser API kan også trekke ut metadata:

offentlig statisk metadataekstrakt MetadatatUsingParser (InputStream stream) kaster IOException, SAXException, TikaException {Parser parser = ny AutoDetectParser (); ContentHandler handler = ny BodyContentHandler (); Metadata metadata = nye metadata (); ParseContext context = ny ParseContext (); parser.parse (stream, handler, metadata, kontekst); returnere metadata; }

Når det finnes en Microsoft Excel-fil på klassestien, bekrefter denne testsaken at de ekstraherte metadataene er riktige:

@Test offentlig ugyldig nårUsingParser_thenMetadataIsReturned () kaster IOException, TikaException, SAXException {InputStream stream = this.getClass (). GetClassLoader () .getResourceAsStream ("tika.xlsx"); Metadata metadata = TikaAnalysis.extractMetadatatUsingParser (stream); assertEquals ("org.apache.tika.parser.DefaultParser", metadata.get ("X-Parsed-By")); assertEquals ("Microsoft Office-bruker", metadata.get ("Forfatter")); stream.close (); }

Til slutt, her er en annen versjon av utvinningsmetoden ved hjelp av Tika fasadeklasse:

offentlig statisk metadataekstrakt MetadatatUsingFacade (InputStream stream) kaster IOException, TikaException {Tika tika = ny Tika (); Metadata metadata = nye metadata (); tika.parse (stream, metadata); returnere metadata; }

6. Konklusjon

Denne opplæringen fokuserte på innholdsanalyse med Apache Tika. Bruker Parser og Detektor APIer, kan vi automatisk oppdage typen av dokument, samt trekke ut innholdet og metadataene.

For avanserte bruksområder kan vi lage tilpassede Parser og Detektor klasser for å ha mer kontroll over analyseprosessen.

Den komplette kildekoden for denne opplæringen finner du på GitHub.

streamalism.org