TIKA - Guia rápido

O que é Apache Tika?

• Apache Tika é uma biblioteca usada para detecção de tipo de documento e extração de conteúdo de vários formatos de arquivo.

• Internamente, a Tika usa vários analisadores de documentos existentes e técnicas de detecção de tipo de documento para detectar e extrair dados.

• Usando o Tika, pode-se desenvolver um detector de tipo universal e extrator de conteúdo para extrair tanto texto estruturado quanto metadados de diferentes tipos de documentos, como planilhas, documentos de texto, imagens, PDFs e até formatos de entrada de multimídia até certo ponto.

• Tika fornece uma única API genérica para analisar diferentes formatos de arquivo. Ele usa bibliotecas de analisador especializadas existentes para cada tipo de documento.

• Todas essas bibliotecas do analisador são encapsuladas em uma única interface chamada de Parser interface.

Por que Tika?

De acordo com filext.com, existem cerca de 15k a 51k tipos de conteúdo, e esse número está crescendo dia a dia. Os dados estão sendo armazenados em vários formatos, como documentos de texto, planilhas do Excel, PDFs, imagens e arquivos multimídia, para citar alguns. Portanto, aplicativos como mecanismos de pesquisa e sistemas de gerenciamento de conteúdo precisam de suporte adicional para facilitar a extração de dados desses tipos de documentos. O Apache Tika atende a esse propósito, fornecendo uma API genérica para localizar e extrair dados de vários formatos de arquivo.

Aplicativos Apache Tika

Existem vários aplicativos que fazem uso do Apache Tika. Aqui, discutiremos alguns aplicativos importantes que dependem muito do Apache Tika.

Motores de busca

Tika é amplamente utilizado no desenvolvimento de mecanismos de pesquisa para indexar o conteúdo de texto de documentos digitais.

• Os mecanismos de pesquisa são sistemas de processamento de informações projetados para pesquisar informações e documentos indexados na web.

• Crawler é um componente importante de um mecanismo de pesquisa que rasteja pela Web para buscar os documentos que devem ser indexados usando alguma técnica de indexação. Depois disso, o crawler transfere esses documentos indexados para um componente de extração.

• A função do componente de extração é extrair o texto e os metadados do documento. Esse conteúdo e metadados extraídos são muito úteis para um mecanismo de pesquisa. Este componente de extração contém Tika.

• O conteúdo extraído é então passado para o indexador do mecanismo de pesquisa que o usa para construir um índice de pesquisa. Além disso, o mecanismo de busca usa o conteúdo extraído de muitas outras maneiras também.

Análise de Documentos

• No campo da inteligência artificial, existem certas ferramentas para analisar documentos automaticamente em nível semântico e extrair todos os tipos de dados deles.

• Nessas aplicações, os documentos são classificados com base nos termos proeminentes no conteúdo extraído do documento.

• Essas ferramentas fazem uso do Tika para extração de conteúdo para analisar documentos que variam de texto simples a documentos digitais.

Gestão de ativos digitais

• Algumas organizações gerenciam seus ativos digitais, como fotografias, ebooks, desenhos, música e vídeo, usando um aplicativo especial conhecido como gerenciamento de ativos digitais (DAM).

• Esses aplicativos usam a ajuda de detectores de tipo de documento e extrator de metadados para classificar os vários documentos.

Análise de conteúdo

• Sites como a Amazon recomendam conteúdos recém-lançados de seu site para usuários individuais de acordo com seus interesses. Para fazer isso, esses sites seguemmachine learning techniquesou tenha a ajuda de sites de mídia social como o Facebook para extrair as informações necessárias, como gostos e interesses dos usuários. Essas informações coletadas estarão na forma de tags html ou outros formatos que requerem detecção e extração de tipo de conteúdo adicional.

• Para a análise de conteúdo de um documento, temos tecnologias que implementam técnicas de aprendizado de máquina, como UIMA e Mahout. Essas tecnologias são úteis para agrupar e analisar os dados nos documentos.

• Apache Mahouté uma estrutura que fornece algoritmos de ML no Apache Hadoop - uma plataforma de computação em nuvem. O Mahout fornece uma arquitetura seguindo certas técnicas de clustering e filtragem. Seguindo essa arquitetura, os programadores podem escrever seus próprios algoritmos de ML para produzir recomendações usando várias combinações de texto e metadados. Para fornecer entradas para esses algoritmos, versões recentes do Mahout usam Tika para extrair texto e metadados de conteúdo binário.

• Apache UIMAanalisa e processa várias linguagens de programação e produz anotações UIMA. Internamente, ele usa o Tika Annotator para extrair o texto e os metadados do documento.

História

Ano	Desenvolvimento
2006	A ideia de Tika foi projetada antes do Comitê de Gerenciamento de Projetos Lucene.
2006	O conceito de Tika e sua utilidade no projeto Jackrabbit foi discutido.
2007	Tika entrou na incubadora Apache.
2008	As versões 0.1 e 0.2 foram lançadas e Tika passou da incubadora para o subprojeto Lucene.
2009	As versões 0.3, 0.4 e 0.5 foram lançadas.
2010	As versões 0.6 e 0.7 foram lançadas e Tika se formou no projeto Apache de nível superior.
2011	Tika 1.0 foi lançado e o livro sobre Tika "Tika in Action" também foi lançado no mesmo ano.

Arquitetura de nível de aplicativo de Tika

Os programadores de aplicativos podem integrar facilmente o Tika em seus aplicativos. Tika fornece uma interface de linha de comando e uma GUI para torná-la amigável.

Neste capítulo, discutiremos os quatro módulos importantes que constituem a arquitetura Tika. A ilustração a seguir mostra a arquitetura do Tika junto com seus quatro módulos -

• Mecanismo de detecção de idioma.
• Mecanismo de detecção de MIME.
• Interface do analisador.
• Aula Tika Facade.

Mecanismo de detecção de linguagem

Sempre que um documento de texto é passado para o Tika, ele detecta o idioma no qual foi escrito. Ele aceita documentos sem anotação de idioma e adiciona essa informação nos metadados do documento, detectando o idioma.

Para apoiar a identificação de idioma, Tika tem uma classe chamada Language Identifier Na embalagem org.apache.tika.language, e um repositório de identificação de idioma dentro do qual contém algoritmos para detecção de idioma de um determinado texto. Tika usa internamente o algoritmo N-gram para detecção de idioma.

Mecanismo de detecção de MIME

Tika pode detectar o tipo de documento de acordo com os padrões MIME. A detecção do tipo MIME padrão no Tika é feita usando org.apache.tika.mime.mimeTypes . Ele usa a interface org.apache.tika.detect.Detector para a maior parte da detecção do tipo de conteúdo.

Internamente, Tika usa várias técnicas, como globs de arquivo, dicas de tipo de conteúdo, bytes mágicos, codificação de caracteres e várias outras técnicas.

Interface do analisador

A interface do analisador de org.apache.tika.parser é a interface chave para analisar documentos no Tika. Essa interface extrai o texto e os metadados de um documento e os resume para usuários externos que desejam escrever plug-ins do analisador.

Usando diferentes classes de analisadores concretos, específicas para tipos de documentos individuais, Tika suporta muitos formatos de documentos. Essas classes específicas de formato fornecem suporte para diferentes formatos de documentos, implementando diretamente a lógica do analisador ou usando bibliotecas de analisador externas.

Tika Facade Class

Usar a classe de fachada Tika é a maneira mais simples e direta de chamar Tika de Java e segue o padrão de design de fachada. Você pode encontrar a classe de fachada Tika no pacote org.apache.tika da API Tika.

Implementando casos de uso básicos, Tika atua como um corretor de paisagem. Ele abstrai a complexidade subjacente da biblioteca Tika, como mecanismo de detecção MIME, interface do analisador e mecanismo de detecção de idioma, e fornece aos usuários uma interface simples de usar.

Características de Tika

• Unified parser Interface- Tika encapsula todas as bibliotecas de analisador de terceiros em uma única interface de analisador. Devido a este recurso, o usuário escapa do fardo de selecionar a biblioteca de analisador adequada e usá-la de acordo com o tipo de arquivo encontrado.

• Low memory usage- Tika consome menos recursos de memória, portanto, é facilmente embutido em aplicativos Java. Também podemos usar o Tika dentro do aplicativo que roda em plataformas com menos recursos, como PDA móvel.

• Fast processing - Pode-se esperar uma rápida detecção e extração de conteúdo de aplicativos.

• Flexible metadata - Tika entende todos os modelos de metadados que são usados ​​para descrever arquivos.

• Parser integration - Tika pode usar várias bibliotecas de analisador disponíveis para cada tipo de documento em um único aplicativo.

• MIME type detection - Tika pode detectar e extrair conteúdo de todos os tipos de mídia incluídos nos padrões MIME.

• Language detection - Tika inclui recurso de identificação de idioma, portanto, pode ser usado em documentos com base no tipo de idioma em sites multilíngues.

Funcionalidades de Tika

Tika suporta várias funcionalidades -

• Detecção de tipo de documento
• Extração de conteúdo
• Extração de metadados
• Detecção de idioma

Detecção de tipo de documento

Tika usa várias técnicas de detecção e detecta o tipo de documento fornecido a ele.

Extração de Conteúdo

Tika tem uma biblioteca de análise que pode analisar o conteúdo de vários formatos de documentos e extraí-los. Depois de detectar o tipo do documento, ele seleciona o analisador apropriado no repositório do analisador e passa o documento. Diferentes classes de Tika possuem métodos para analisar diferentes formatos de documentos.

Extração de Metadados

Junto com o conteúdo, Tika extrai os metadados do documento com o mesmo procedimento da extração de conteúdo. Para alguns tipos de documentos, Tika tem classes para extrair metadados.

Detecção de idioma

Internamente, Tika segue algoritmos como n-grampara detectar o idioma do conteúdo em um determinado documento. Tika depende de aulas comoLanguageidentifier e Profiler para identificação de idioma.

Este capítulo o conduz pelo processo de configuração do Apache Tika no Windows e Linux. A administração do usuário é necessária durante a instalação do Apache Tika.

Requisitos de sistema

JDK	Java SE 2 JDK 1.6 ou superior
Memória	1 GB de RAM (recomendado)
Espaço em disco	Sem requisitos mínimos
Versão do sistema operacional	Windows XP ou superior, Linux

Etapa 1: Verificar a instalação do Java

Para verificar a instalação do Java, abra o console e execute o seguinte java comando.

SO	Tarefa	Comando
janelas	Abra o console de comando	\> java –version
Linux	Abra o terminal de comando	$ java –version

Se o Java foi instalado corretamente em seu sistema, você deve obter uma das seguintes saídas, dependendo da plataforma em que está trabalhando.

SO	Resultado
janelas	Versão Java "1.7.0_60" Java (TM) SE Run Time Environment (build 1.7.0_60-b19) Java Hotspot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Lunix	versão java "1.7.0_25" Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) Abra o servidor VM JDK de 64 bits (compilação 23.7-b01, modo misto)

• Presumimos que os leitores deste tutorial tenham o Java 1.7.0_60 instalado em seus sistemas antes de prosseguir para este tutorial.

• Caso você não tenha Java SDK, baixe sua versão atual em https://www.oracle.com/technetwork/java/javase/downloads/index.html and have it installed.

Etapa 2: configuração do ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

SO	Resultado
janelas	Defina a variável ambiental JAVA_HOME para C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux	export JAVA_HOME = / usr / local / java-current

Anexe o caminho completo do local do compilador Java ao caminho do sistema.

SO	Resultado
janelas	Anexar a string; C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ bin ao final da variável de sistema PATH.
Linux	exportar PATH = $ PATH: $ JAVA_HOME / bin /

Verifique o comando java-version no prompt de comando conforme explicado acima.

Etapa 3: Configurando o ambiente Apache Tika

Os programadores podem integrar o Apache Tika em seu ambiente usando

• Linha de comando,
• API Tika,
• Interface de linha de comando (CLI) de Tika,
• Interface gráfica do usuário (GUI) de Tika, ou
• o código-fonte.

Para qualquer uma dessas abordagens, em primeiro lugar, você deve baixar o código-fonte do Tika.

Você encontrará o código-fonte do Tika em https://Tika.apache.org/download.html, onde você encontrará dois links -

• apache-tika-1.6-src.zip - Contém o código-fonte do Tika, e

• Tika -app-1.6.jar - É um arquivo jar que contém o aplicativo Tika.

Baixe esses dois arquivos. Um instantâneo do site oficial da Tika é mostrado abaixo.

Depois de baixar os arquivos, defina o classpath para o arquivo jar tika-app-1.6.jar. Adicione o caminho completo do arquivo jar conforme mostrado na tabela abaixo.

SO	Resultado
janelas	Anexe a string “C: \ jars \ Tika-app-1.6.jar” à variável de ambiente do usuário CLASSPATH
Linux	Exportar CLASSPATH = $ CLASSPATH - /usr/share/jars/Tika-app-1.6.tar -

O Apache fornece o aplicativo Tika, um aplicativo de interface gráfica do usuário (GUI) usando Eclipse.

Tika-Maven Build usando Eclipse

• Abra o eclipse e crie um novo projeto.

• Se você não tiver o Maven em seu Eclipse, configure-o seguindo as etapas fornecidas.

  • Abra o link https://wiki.eclipse.org/M2E_updatesite_and_gittags . Lá você encontrará os lançamentos do plugin m2e em um formato tabular

• Escolha a versão mais recente e salve o caminho do url na coluna p2 url.

• Agora revisite o eclipse, na barra de menu, clique Helpe escolha Install New Software no menu suspenso

• Clique no Addbotão, digite qualquer nome desejado, pois é opcional. Agora cole o url salvo noLocation campo.

• Um novo plug-in será adicionado com o nome que você escolheu na etapa anterior, marque a caixa de seleção na frente dele e clique Next.

• Continue com a instalação. Depois de concluído, reinicie o Eclipse.

• Agora clique com o botão direito do mouse no projeto e no configure opção, selecione convert to maven project.

• Um novo assistente para criar um novo pom aparece. Insira o ID do grupo como org.apache.tika, insira a versão mais recente do Tika, selecione opackaging como jarra e clique Finish.

O projeto Maven foi instalado com sucesso e seu projeto foi convertido em Maven. Agora você deve configurar o arquivo pom.xml.

Configure o arquivo XML

Obtenha a dependência do maven Tika dehttps://mvnrepository.com/artifact/org.apache.tika

Abaixo é mostrada a dependência Maven completa do Apache Tika.

<dependency>
   <groupId>org.apache.Tika</groupId>
   <artifactId>Tika-core</artifactId>
   <version>1.6</version>

   <groupId>org.apache.Tika</groupId>
   <artifactId> Tika-parsers</artifactId>
   <version> 1.6</version>

   <groupId> org.apache.Tika</groupId>
   <artifactId>Tika</artifactId>
   <version>1.6</version>

   <groupId>org.apache.Tika</groupId>
   < artifactId>Tika-serialization</artifactId>
   < version>1.6< /version>

   < groupId>org.apache.Tika< /groupId>
   < artifactId>Tika-app< /artifactId>
   < version>1.6< /version>

   <groupId>org.apache.Tika</groupId>
   <artifactId>Tika-bundle</artifactId>
   <version>1.6</version>
</dependency>

Os usuários podem incorporar Tika em seus aplicativos usando a classe de fachada Tika. Possui métodos para explorar todas as funcionalidades do Tika. Por ser uma classe de fachada, Tika abstrai a complexidade por trás de suas funções. Além disso, os usuários também podem usar as várias classes de Tika em seus aplicativos.

Classe Tika (fachada)

Esta é a classe mais proeminente da biblioteca Tika e segue o padrão de design de fachada. Portanto, ele abstrai todas as implementações internas e fornece métodos simples para acessar as funcionalidades do Tika. A tabela a seguir lista os construtores desta classe junto com suas descrições.

package - org.apache.tika

class - Tika

Sr. Não.	Construtor e descrição
1	Tika () Usa a configuração padrão e constrói a classe Tika.
2	Tika (Detector detector) Cria uma fachada Tika aceitando a instância do detector como parâmetro
3	Tika (Detector detector, Parser parser) Cria uma fachada Tika aceitando as instâncias do detector e do analisador como parâmetros.
4	Tika (Detector detector, Parser parser, Translator translator) Cria uma fachada Tika aceitando o detector, o analisador e a instância do tradutor como parâmetros.
5	Tika (TikaConfig config) Cria uma fachada Tika aceitando o objeto da classe TikaConfig como parâmetro.

Métodos e Descrição

A seguir estão os métodos importantes da classe de fachada Tika -

Sr. Não.	Métodos e Descrição
1	analisarToString (File Arquivo) Este método e todas as suas variantes analisa o arquivo passado como parâmetro e retorna o conteúdo do texto extraído no formato String. Por padrão, o comprimento desse parâmetro de string é limitado.
2	int getMaxStringLength () Retorna o comprimento máximo das strings retornadas pelos métodos parseToString.
3	vazio setMaxStringLength (int maxStringLength) Define o comprimento máximo das strings retornadas pelos métodos parseToString.
4	Leitor parse (File Arquivo) Este método e todas as suas variantes analisa o arquivo passado como parâmetro e retorna o conteúdo do texto extraído na forma do objeto java.io.reader.
5	Corda detect (InputStream corrente, Metadata metadados) Este método e todas as suas variantes aceitam um objeto InputStream e um objeto Metadata como parâmetros, detecta o tipo do documento fornecido e retorna o nome do tipo de documento como objeto String. Este método abstrai os mecanismos de detecção usados ​​por Tika.
6	Corda translate (InputStream texto, String targetLanguage) Este método e todas as suas variantes aceita o objeto InputStream e uma String que representa o idioma para o qual queremos que nosso texto seja traduzido e traduz o texto fornecido para o idioma desejado, tentando detectar automaticamente o idioma de origem.

Interface do analisador

Esta é a interface que é implementada por todas as classes de analisador do pacote Tika.

package - org.apache.tika.parser

Interface - Parser

Métodos e Descrição

A seguir está o método importante da interface do Tika Parser -

Sr. Não.	Métodos e Descrição
1	parse (InputStream stream, ContentHandler handler, Metadata metadata, ParseContext context) Este método analisa o documento fornecido em uma sequência de eventos XHTML e SAX. Após a análise, ele coloca o conteúdo do documento extraído no objeto da classe ContentHandler e os metadados no objeto da classe Metadata.

Classe de Metadados

Esta classe implementa várias interfaces, como CreativeCommons, Geographic, HttpHeaders, Message, MSOffice, ClimateForcast, TIFF, TikaMetadataKeys, TikaMimeKeys, Serializable para suportar vários modelos de dados. As tabelas a seguir listam os construtores e métodos desta classe junto com suas descrições.

package - org.apache.tika.metadata

class - Metadados

Sr. Não.	Construtor e descrição
1	Metadata() Constrói metadados novos e vazios.

Sr. Não.	Métodos e Descrição
1	add (Property property, String value) Adiciona um mapeamento de propriedade / valor de metadados a um determinado documento. Usando esta função, podemos definir o valor de uma propriedade.
2	add (String name, String value) Adiciona um mapeamento de propriedade / valor de metadados a um determinado documento. Usando este método, podemos definir um novo valor de nome para os metadados existentes de um documento.
3	String get (Property property) Retorna o valor (se houver) da propriedade de metadados fornecida.
4	String get (String name) Retorna o valor (se houver) do nome de metadados fornecido.
5	Date getDate (Property property) Retorna o valor da propriedade de metadados Date.
6	String[] getValues (Property property) Retorna todos os valores de uma propriedade de metadados.
7	String[] getValues (String name) Retorna todos os valores de um determinado nome de metadados.
8	String[] names() Retorna todos os nomes de elementos de metadados em um objeto de metadados.
9	set (Property property, Date date) Define o valor da data da propriedade de metadados fornecida
10	set(Property property, String[] values) Define vários valores para uma propriedade de metadados.

Classe Identificadora de Idioma

Esta classe identifica o idioma do conteúdo fornecido. As tabelas a seguir listam os construtores desta classe junto com suas descrições.

package - org.apache.tika.language

class - Identificador de idioma

Sr. Não.	Construtor e descrição
1	LanguageIdentifier (LanguageProfile profile) Instancia o identificador do idioma. Aqui você deve passar um objeto LanguageProfile como parâmetro.
2	LanguageIdentifier (String content) Este construtor pode instanciar um identificador de idioma passando uma String do conteúdo do texto.

Sr. Não.	Métodos e Descrição
1	String getLanguage () Retorna o idioma fornecido ao objeto LanguageIdentifier atual.

Formatos de arquivo suportados por Tika

A tabela a seguir mostra os formatos de arquivo suportados pelo Tika.

Formato de arquivo	Biblioteca de Pacotes	Aula em Tika
XML	org.apache.tika.parser.xml	XMLParser
HTML	org.apache.tika.parser.html e usa a Biblioteca Tagsoup	HtmlParser
Documento composto do MS-Office Ole2 até 2007 ooxml 2007 em diante	org.apache.tika.parser.microsoft org.apache.tika.parser.microsoft.ooxml e usa a biblioteca Apache Poi	OfficeParser (ole2) OOXMLParser (ooxml)
OpenDocument Format openoffice	org.apache.tika.parser.odf	OpenOfficeParser
Portable Document Format (PDF)	org.apache.tika.parser.pdf e este pacote usa a biblioteca Apache PdfBox	PDFParser
Formato de publicação eletrônica (livros digitais)	org.apache.tika.parser.epub	EpubParser
Formato de texto rico	org.apache.tika.parser.rtf	RTFParser
Formatos de compressão e embalagem	org.apache.tika.parser.pkg e este pacote usa a biblioteca de compressão comum	PackageParser e CompressorParser e suas subclasses
Formato de texto	org.apache.tika.parser.txt	TXTParser
Formatos de feed e distribuição	org.apache.tika.parser.feed	FeedParser
Formatos de áudio	org.apache.tika.parser.audio e org.apache.tika.parser.mp3	AudioParser MidiParser Mp3- para mp3parser
Imageparsers	org.apache.tika.parser.jpeg	JpegParser - para imagens jpeg
Videoformatos	org.apache.tika.parser.mp4 e org.apache.tika.parser.video este analisador usa internamente Algoritmo Simples para analisar formatos de vídeo em flash	Mp4parser FlvParser
arquivos de classe java e arquivos jar	org.apache.tika.parser.asm	ClassParser CompressorParser
Mobxformat (mensagens de e-mail)	org.apache.tika.parser.mbox	MobXParser
Formatos Cad	org.apache.tika.parser.dwg	DWGParser
FontFormats	org.apache.tika.parser.font	TrueTypeParser
programas executáveis ​​e bibliotecas	org.apache.tika.parser.executable	ExecutableParser

Padrões MIME

Os padrões Multipurpose Internet Mail Extensions (MIME) são os melhores padrões disponíveis para identificar tipos de documentos. O conhecimento desses padrões ajuda o navegador durante as interações internas.

Sempre que o navegador encontra um arquivo de mídia, ele escolhe um software compatível disponível com ele para exibir seu conteúdo. Caso não tenha nenhum aplicativo adequado para executar um determinado arquivo de mídia, recomenda ao usuário obter o software de plugin adequado para ele.

Detecção de tipo em Tika

Tika suporta todos os tipos de documentos de mídia da Internet fornecidos em MIME. Sempre que um arquivo é passado pelo Tika, ele detecta o arquivo e seu tipo de documento. Para detectar tipos de mídia, a Tika usa internamente os seguintes mecanismos.

Extensões de arquivo

Verificar as extensões de arquivo é o método mais simples e mais amplamente usado para detectar o formato de um arquivo. Muitos aplicativos e sistemas operacionais fornecem suporte para essas extensões. Abaixo são mostradas as extensões de alguns tipos de arquivos conhecidos.

Nome do arquivo	Extensão
imagem	.jpg
audio	.mp3
arquivo java	.jar
arquivo de classe java	.classe

Dicas de tipo de conteúdo

Sempre que você recuperar um arquivo de um banco de dados ou anexá-lo a outro documento, poderá perder o nome ou a extensão do arquivo. Nesses casos, os metadados fornecidos com o arquivo são usados ​​para detectar a extensão do arquivo.

Byte mágico

Observando os bytes brutos de um arquivo, você pode encontrar alguns padrões de caracteres exclusivos para cada arquivo. Alguns arquivos têm prefixos de bytes especiais chamadosmagic bytes que são feitos especialmente e incluídos em um arquivo com a finalidade de identificar o tipo de arquivo

Por exemplo, você pode encontrar CA FE BA BE (formato hexadecimal) em um arquivo java e% PDF (formato ASCII) em um arquivo pdf. Tika usa essas informações para identificar o tipo de mídia de um arquivo.

Codificações de caracteres

Os arquivos com texto simples são codificados usando diferentes tipos de codificação de caracteres. O principal desafio aqui é identificar o tipo de codificação de caracteres usada nos arquivos. Tika segue técnicas de codificação de caracteres comoBom markers e Byte Frequencies para identificar o sistema de codificação usado pelo conteúdo de texto simples.

Caracteres XML Root

Para detectar documentos XML, Tika analisa os documentos xml e extrai as informações como elementos raiz, namespaces e esquemas referenciados de onde o verdadeiro tipo de mídia dos arquivos pode ser encontrado.

Detecção de tipo usando classe de fachada

o detect()método da classe de fachada é usado para detectar o tipo de documento. Este método aceita um arquivo como entrada. Abaixo, é mostrado um programa de exemplo para detecção de tipo de documento com a classe Tika Fachada

import java.io.File;

import org.apache.tika.Tika;

public class Typedetection {

   public static void main(String[] args) throws Exception {

      //assume example.mp3 is in your current directory
      File file = new File("example.mp3");//
      
      //Instantiating tika facade class 
      Tika tika = new Tika();
      
      //detecting the file type using detect method
      String filetype = tika.detect(file);
      System.out.println(filetype);
   }
}

Salve o código acima como TypeDetection.java e execute-o no prompt de comando usando os seguintes comandos -

javac TypeDetection.java
java TypeDetection 

audio/mpeg

Tika usa várias bibliotecas de analisadores para extrair conteúdo de determinados analisadores. Ele escolhe o analisador correto para extrair o tipo de documento fornecido.

Para analisar documentos, o método parseToString () da classe de fachada Tika é geralmente usado. Abaixo, são mostradas as etapas envolvidas no processo de análise e são abstraídas pelo método Tika ParsertoString ().

Abstraindo o processo de análise -

• Inicialmente, quando passamos um documento para Tika, ele usa um mecanismo de detecção de tipo adequado disponível com ele e detecta o tipo de documento.

• Uma vez que o tipo de documento é conhecido, ele escolhe um analisador adequado em seu repositório de analisador. O repositório do analisador contém classes que fazem uso de bibliotecas externas.

• Em seguida, o documento é passado para escolher o analisador que analisará o conteúdo, extrairá o texto e também lançará exceções para formatos ilegíveis.

Extração de conteúdo usando Tika

A seguir está o programa para extrair texto de um arquivo usando a classe de fachada Tika -

import java.io.File;
import java.io.IOException;

import org.apache.tika.Tika;
import org.apache.tika.exception.TikaException;

import org.xml.sax.SAXException;

public class TikaExtraction {
	
   public static void main(final String[] args) throws IOException, TikaException {

      //Assume sample.txt is in your current directory		        
      File file = new File("sample.txt");
      
      //Instantiating Tika facade class
      Tika tika = new Tika();
      String filecontent = tika.parseToString(file);
      System.out.println("Extracted Content: " + filecontent);
   }		 
}

Salve o código acima como TikaExtraction.java e execute-o no prompt de comando -

javac TikaExtraction.java 
java TikaExtraction

Abaixo está o conteúdo de sample.txt.

Hi students welcome to tutorialspoint

Ele fornece a seguinte saída -

Extracted Content: Hi students welcome to tutorialspoint

Extração de conteúdo usando a interface do analisador

O pacote analisador de Tika fornece várias interfaces e classes com as quais podemos analisar um documento de texto. A seguir está o diagrama de blocos doorg.apache.tika.parser pacote.

Existem várias classes de analisador disponíveis, por exemplo, analisador de pdf, Mp3Passer, OfficeParser, etc., para analisar os respectivos documentos individualmente. Todas essas classes implementam a interface do analisador.

CompositeParser

O diagrama fornecido mostra as classes do analisador de propósito geral de Tika: CompositeParser e AutoDetectParser. Como a classe CompositeParser segue o padrão de design composto, você pode usar um grupo de instâncias do analisador como um único analisador. A classe CompositeParser também permite acesso a todas as classes que implementam a interface do analisador.

AutoDetectParser

Esta é uma subclasse de CompositeParser e fornece detecção automática de tipo. Usando essa funcionalidade, o AutoDetectParser envia automaticamente os documentos recebidos para as classes de analisador apropriadas usando a metodologia composta.

método parse ()

Junto com parseToString (), você também pode usar o método parse () da interface do analisador. O protótipo deste método é mostrado abaixo.

parse(InputStream stream, ContentHandler handler, Metadata metadata, ParseContext context)

A tabela a seguir lista os quatro objetos que aceita como parâmetros.

Sr. Não.	Objeto e descrição
1	InputStream stream Qualquer objeto Inputstream que contém o conteúdo do arquivo
2	ContentHandler handler Tika passa o documento como conteúdo XHTML para esse manipulador, depois disso, o documento é processado usando a API SAX. Ele fornece pós-processamento eficiente do conteúdo de um documento.
3	Metadata metadata O objeto de metadados é usado como fonte e destino dos metadados do documento.
4	ParseContext context Este objeto é usado nos casos em que o aplicativo cliente deseja personalizar o processo de análise.

Exemplo

Abaixo está um exemplo que mostra como o método parse () é usado.

Step 1 -

Para usar o método parse () da interface do analisador, instancie qualquer uma das classes que fornecem a implementação para essa interface.

Existem classes de analisadores individuais, como PDFParser, OfficeParser, XMLParser, etc. Você pode usar qualquer um desses analisadores de documentos individuais. Como alternativa, você pode usar CompositeParser ou AutoDetectParser que usa todas as classes de analisador internamente e extrai o conteúdo de um documento usando um analisador adequado.

Parser parser = new AutoDetectParser();
   (or)
Parser parser = new CompositeParser();  
   (or)        
object of any individual parsers given in Tika Library

Step 2 -

Crie um objeto de classe de manipulador. Abaixo estão os três gerenciadores de conteúdo -

Sr. Não.	Classe e descrição
1	BodyContentHandler Esta classe escolhe a parte do corpo da saída XHTML e grava esse conteúdo no gravador de saída ou fluxo de saída. Em seguida, ele redireciona o conteúdo XHTML para outra instância do manipulador de conteúdo.
2	LinkContentHandler Esta classe detecta e escolhe todas as tags H-Ref do documento XHTML e as encaminha para o uso de ferramentas como rastreadores da web.
3	TeeContentHandler Esta classe ajuda a usar várias ferramentas simultaneamente.

Como nosso objetivo é extrair o conteúdo de texto de um documento, instancie BodyContentHandler conforme mostrado abaixo -

BodyContentHandler handler = new BodyContentHandler( );

Step 3 -

Crie o objeto de Metadados conforme mostrado abaixo -

Metadata metadata = new Metadata();

Step 4 -

Crie qualquer um dos objetos de fluxo de entrada e passe o arquivo que deve ser extraído para ele.

FileInputstream

Instancie um objeto de arquivo passando o caminho do arquivo como parâmetro e passe esse objeto para o construtor da classe FileInputStream.

Note - O caminho passado para o objeto de arquivo não deve conter espaços.

O problema com essas classes de fluxo de entrada é que elas não suportam leituras de acesso aleatório, o que é necessário para processar alguns formatos de arquivo com eficiência. Para resolver esse problema, a Tika fornece TikaInputStream.

File  file = new File(filepath)
FileInputStream inputstream = new FileInputStream(file);
   (or)
InputStream stream = TikaInputStream.get(new File(filename));

Step 5 -

Crie um objeto de contexto de análise conforme mostrado abaixo -

ParseContext context =new ParseContext();

Step 6 -

Instancie o objeto analisador, invoque o método parse e passe todos os objetos necessários, conforme mostrado no protótipo abaixo -

parser.parse(inputstream, handler, metadata, context);

A seguir está o programa para extração de conteúdo usando a interface do analisador -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class ParserExtraction {
	
   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //Assume sample.txt is in your current directory
      File file = new File("sample.txt");
      
      //parse method parameters
      Parser parser = new AutoDetectParser();
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(file);
      ParseContext context = new ParseContext();
      
      //parsing the file
      parser.parse(inputstream, handler, metadata, context);
      System.out.println("File content : " + Handler.toString());
   }
}

Salve o código acima como ParserExtraction.java e execute-o no prompt de comando -

javac  ParserExtraction.java 
java  ParserExtraction

A seguir está o conteúdo de sample.txt

Hi students welcome to tutorialspoint

Se você executar o programa acima, ele fornecerá a seguinte saída -

File content : Hi students welcome to tutorialspoint

Além do conteúdo, Tika também extrai os metadados de um arquivo. Metadados nada mais são do que informações adicionais fornecidas com um arquivo. Se considerarmos um arquivo de áudio, o nome do artista, o nome do álbum, o título vêm sob os metadados.

Padrões XMP

A Extensible Metadata Platform (XMP) é um padrão para processar e armazenar informações relacionadas ao conteúdo de um arquivo. Foi criado pela Adobe Systems Inc . O XMP fornece padrões para definir, criar e processar metadados . Você pode incorporar este padrão em vários formatos de arquivo, como PDF , JPEG , JPEG , GIF , jpg , HTML etc.

Classe de Propriedade

Tika usa a classe Property para seguir a definição da propriedade XMP. Ele fornece os enums PropertyType e ValueType para capturar o nome e o valor de um metadado.

Classe de Metadados

Esta classe implementa várias interfaces, como ClimateForcast , CativeCommons, Geographic , TIFF etc. para fornecer suporte para vários modelos de metadados. Além disso, essa classe fornece vários métodos para extrair o conteúdo de um arquivo.

Nomes de Metadados

Podemos extrair a lista de todos os nomes de metadados de um arquivo de seu objeto de metadados usando os nomes de método () . Ele retorna todos os nomes como uma matriz de string. Usando o nome dos metadados, podemos obter o valor usando oget()método. Recebe um nome de metadados e retorna um valor associado a ele.

String[] metadaNames = metadata.names();

String value = metadata.get(name);

Extração de metadados usando o método de análise

Sempre que analisamos um arquivo usando parse (), passamos um objeto de metadados vazio como um dos parâmetros. Este método extrai os metadados do arquivo fornecido (se esse arquivo contiver algum) e os coloca no objeto de metadados. Portanto, depois de analisar o arquivo usando parse (), podemos extrair os metadados desse objeto.

Parser parser = new AutoDetectParser();
BodyContentHandler handler = new BodyContentHandler();
Metadata metadata = new Metadata();   //empty metadata object 
FileInputStream inputstream = new FileInputStream(file);
ParseContext context = new ParseContext();
parser.parse(inputstream, handler, metadata, context);

// now this metadata object contains the extracted metadata of the given file.
metadata.metadata.names();

A seguir está o programa completo para extrair metadados de um arquivo de texto.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class GetMetadata {
	
   public static void main(final String[] args) throws IOException, TikaException {
	
      //Assume that boy.jpg is in your current directory
      File file = new File("boy.jpg");

      //Parser method parameters
      Parser parser = new AutoDetectParser();
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(file);
      ParseContext context = new ParseContext();
      
      parser.parse(inputstream, handler, metadata, context);
      System.out.println(handler.toString());

      //getting the list of all meta data elements 
      String[] metadataNames = metadata.names();

      for(String name : metadataNames) {		        
         System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como GetMetadata.java e execute-o no prompt de comando usando os seguintes comandos -

javac  GetMetadata .java
java  GetMetadata

Abaixo está o instantâneo de boy.jpg

Se você executar o programa acima, ele fornecerá a seguinte saída -

X-Parsed-By: org.apache.tika.parser.DefaultParser
Resolution Units: inch
Compression Type: Baseline
Data Precision: 8 bits
Number of Components: 3
tiff:ImageLength: 3000
Component 2: Cb component: Quantization table 1, Sampling factors 1 horiz/1 vert
Component 1: Y component: Quantization table 0, Sampling factors 2 horiz/2 vert
Image Height: 3000 pixels
X Resolution: 300 dots
Original Transmission Reference:
   53616c7465645f5f2368da84ca932841b336ac1a49edb1a93fae938b8db2cb3ec9cc4dc28d7383f1
Image Width: 4000 pixels
IPTC-NAA record: 92 bytes binary data
Component 3: Cr component: Quantization table 1, Sampling factors 1 horiz/1 vert
tiff:BitsPerSample: 8
Application Record Version: 4
tiff:ImageWidth: 4000
Content-Type: image/jpeg
Y Resolution: 300 dots

Também podemos obter nossos valores de metadados desejados.

Adicionando Novos Valores de Metadados

Podemos adicionar novos valores de metadados usando o método add () da classe de metadados. A seguir está a sintaxe desse método. Aqui estamos adicionando o nome do autor.

metadata.add(“author”,”Tutorials point”);

A classe Metadata possui propriedades predefinidas, incluindo as propriedades herdadas de classes como ClimateForcast , CativeCommons, Geographic , etc., para oferecer suporte a vários modelos de dados. Abaixo, é mostrado o uso do tipo de dados SOFTWARE herdado da interface TIFF implementada pela Tika para seguir os padrões de metadados XMP para formatos de imagem TIFF.

metadata.add(Metadata.SOFTWARE,"ms paint");

A seguir está o programa completo que demonstra como adicionar valores de metadados a um determinado arquivo. Aqui, a lista dos elementos de metadados é exibida na saída para que você possa observar a mudança na lista após adicionar novos valores.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class AddMetadata {

   public static void main(final String[] args) throws IOException, SAXException, TikaException {

      //create a file object and assume sample.txt is in your current directory
      File file = new File("Example.txt");

      //Parser method parameters
      Parser parser = new AutoDetectParser();
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(file);
      ParseContext context = new ParseContext();

      //parsing the document
      parser.parse(inputstream, handler, metadata, context);

      //list of meta data elements before adding new elements
      System.out.println( " metadata elements :"  +Arrays.toString(metadata.names()));

      //adding new meta data name value pair
      metadata.add("Author","Tutorials Point");
      System.out.println(" metadata name value pair is successfully added");
      
      //printing all the meta data elements after adding new elements
      System.out.println("Here is the list of all the metadata 
         elements after adding new elements");
      System.out.println( Arrays.toString(metadata.names()));
   }
}

Salve o código acima como classe AddMetadata.java e execute-o no prompt de comando -

javac  AddMetadata .java 
java  AddMetadata

Abaixo está o conteúdo de Example.txt

Hi students welcome to tutorialspoint

Se você executar o programa acima, ele fornecerá a seguinte saída -

metadata elements of the given file :
[Content-Encoding, Content-Type] 
enter the number of metadata name value pairs to be added 1
enter metadata1name: 
Author enter metadata1value: 
Tutorials point metadata name value pair is successfully added
Here is the list of all the metadata elements  after adding new elements
[Content-Encoding, Author, Content-Type]

Definindo Valores para Elementos de Metadados Existentes

Você pode definir valores para os elementos de metadados existentes usando o método set (). A sintaxe para definir a propriedade de data usando o método set () é a seguinte -

metadata.set(Metadata.DATE, new Date());

Você também pode definir vários valores para as propriedades usando o método set (). A sintaxe para definir vários valores para a propriedade Author usando o método set () é a seguinte -

metadata.set(Metadata.AUTHOR, "ram ,raheem ,robin ");

Abaixo está o programa completo que demonstra o método set ().

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import java.util.Date;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class SetMetadata {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {
   
      //Create a file object and assume example.txt is in your current directory
      File file = new File("example.txt");
      
      //parameters of parse() method
      Parser parser = new AutoDetectParser();
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(file);
      ParseContext context = new ParseContext();
      
      //Parsing the given file
      parser.parse(inputstream, handler, metadata, context);
     
      //list of meta data elements elements
      System.out.println( " metadata elements and values of the given file :");
      String[] metadataNamesb4 = metadata.names();
      
      for(String name : metadataNamesb4) {
    	  System.out.println(name + ": " + metadata.get(name));
      }
      
      //setting date meta data 
      metadata.set(Metadata.DATE, new Date());
      
      //setting multiple values to author property
      metadata.set(Metadata.AUTHOR, "ram ,raheem ,robin ");
      
      //printing all the meta data elements with new elements
      System.out.println("List of all the metadata elements  after adding new elements ");
      String[] metadataNamesafter = metadata.names();
      
      for(String name : metadataNamesafter) {
         System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como SetMetadata.java e execute-o no prompt de comando -

javac  SetMetadata.java 
java  SetMetadata

A seguir está o conteúdo de example.txt.

Hi students welcome to tutorialspoint

Se você executar o programa acima, ele fornecerá a seguinte saída. Na saída, você pode observar os elementos de metadados recém-adicionados.

metadata elements and values of the given file :
Content-Encoding: ISO-8859-1
Content-Type: text/plain; charset = ISO-8859-1
Here is the list of all the metadata elements  after adding new elements 
date: 2014-09-24T07:01:32Z
Content-Encoding: ISO-8859-1
Author: ram, raheem, robin 
Content-Type: text/plain; charset = ISO-8859-1

Necessidade de detecção de idioma

Para a classificação de documentos com base no idioma em que são escritos em um site multilíngue, é necessária uma ferramenta de detecção de idioma. Esta ferramenta deve aceitar documentos sem anotação de idioma (metadados) e adicionar essa informação nos metadados do documento detectando o idioma.

Algoritmos para Profiling Corpus

O que é Corpus?

Para detectar o idioma de um documento, um perfil de idioma é construído e comparado com o perfil dos idiomas conhecidos. O conjunto de textos desses idiomas conhecidos é conhecido como umcorpus.

Um corpus é uma coleção de textos de uma linguagem escrita que explica como a linguagem é usada em situações reais.

O corpus é desenvolvido a partir de livros, transcrições e outros recursos de dados como a Internet. A precisão do corpus depende do algoritmo de criação de perfil que usamos para enquadrar o corpus.

O que são algoritmos de criação de perfil?

A maneira comum de detectar idiomas é usando dicionários. As palavras usadas em um determinado texto serão comparadas com aquelas que estão nos dicionários.

Uma lista de palavras comuns usadas em um idioma será o corpus mais simples e eficaz para detectar um determinado idioma, por exemplo, artigos a, an, the em inglês.

Usando Conjuntos de Palavras como Corpus

Usando conjuntos de palavras, um algoritmo simples é estruturado para encontrar a distância entre dois corpora, que será igual à soma das diferenças entre as frequências de palavras correspondentes.

Esses algoritmos sofrem dos seguintes problemas -

• Uma vez que a frequência de palavras correspondentes é muito menor, o algoritmo não pode trabalhar de forma eficiente com textos pequenos com poucas frases. Necessita de muito texto para uma correspondência precisa.

• Ele não pode detectar limites de palavras para idiomas com frases compostas e aqueles que não têm divisores de palavras, como espaços ou sinais de pontuação.

Devido a essas dificuldades em usar conjuntos de palavras como corpus, caracteres individuais ou grupos de caracteres são considerados.

Usando conjuntos de caracteres como corpus

Como os caracteres comumente usados ​​em um idioma são finitos em número, é fácil aplicar um algoritmo baseado em frequências de palavras em vez de caracteres. Este algoritmo funciona ainda melhor no caso de certos conjuntos de caracteres usados ​​em um ou poucos idiomas.

Este algoritmo sofre das seguintes desvantagens -

• É difícil diferenciar dois idiomas com frequências de caracteres semelhantes.

• Não existe uma ferramenta ou algoritmo específico para identificar especificamente um idioma com a ajuda (como corpus) do conjunto de caracteres usado por vários idiomas.

Algoritmo N-gram

As desvantagens indicadas acima deram origem a uma nova abordagem de uso de sequências de caracteres de um determinado comprimento para o corpus de perfil. Essa seqüência de caracteres é chamada de N-gramas em geral, onde N representa o comprimento da seqüência de caracteres.

• O algoritmo N-gram é uma abordagem eficaz para detecção de idiomas, especialmente no caso de idiomas europeus como o inglês.

• Este algoritmo funciona bem com textos curtos.

• Embora existam algoritmos de perfil de idioma avançados para detectar vários idiomas em um documento multilíngue com recursos mais atraentes, Tika usa o algoritmo de 3 gramas, pois é adequado na maioria das situações práticas.

Detecção de idioma em Tika

Entre todos os 184 idiomas padronizados pela ISO 639-1, o Tika pode detectar 18 idiomas. A detecção de idioma no Tika é feita usando ogetLanguage() método do LanguageIdentifierclasse. Este método retorna o nome do código do idioma no formato String. A seguir está a lista dos 18 pares de códigos de idioma detectados por Tika -

da — dinamarquês	de — alemão	et — estoniano	el — grego
en — inglês	es — espanhol	fi — finlandês	fr — francês
hu — húngaro	é — islandês	it — italiano	nl — holandês
não — norueguês	pl — polonês	pt — português	ru — russo
sv — sueco	th — tailandês

Ao instanciar o LanguageIdentifier classe, você deve passar o formato String do conteúdo a ser extraído, ou um LanguageProfile objeto de classe.

LanguageIdentifier object = new LanguageIdentifier(“this is english”);

A seguir está o programa de exemplo para detecção de idioma em Tika.

import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.language.LanguageIdentifier;

import org.xml.sax.SAXException;

public class LanguageDetection {

   public static void main(String args[])throws IOException, SAXException, TikaException {

      LanguageIdentifier identifier = new LanguageIdentifier("this is english ");
      String language = identifier.getLanguage();
      System.out.println("Language of the given content is : " + language);
   }
}

Salve o código acima como LanguageDetection.java e execute-o a partir do prompt de comando usando os seguintes comandos -

javac  LanguageDetection.java 
java  LanguageDetection

Se você executar o programa acima, ele dará o seguinte resultado

Language of the given content is : en

Detecção de idioma de um documento

Para detectar o idioma de um determinado documento, você deve analisá-lo usando o método parse (). O método parse () analisa o conteúdo e o armazena no objeto manipulador, que foi passado a ele como um dos argumentos. Passe o formato String do objeto manipulador para o construtor doLanguageIdentifier classe como mostrado abaixo -

parser.parse(inputstream, handler, metadata, context);
LanguageIdentifier object = new LanguageIdentifier(handler.toString());

Abaixo está o programa completo que demonstra como detectar o idioma de um determinado documento -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.BodyContentHandler;
import org.apache.tika.language.*;

import org.xml.sax.SAXException;

public class DocumentLanguageDetection {

   public static void main(final String[] args) throws IOException, SAXException, TikaException {

      //Instantiating a file object
      File file = new File("Example.txt");

      //Parser method parameters
      Parser parser = new AutoDetectParser();
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream content = new FileInputStream(file);

      //Parsing the given document
      parser.parse(content, handler, metadata, new ParseContext());

      LanguageIdentifier object = new LanguageIdentifier(handler.toString());
      System.out.println("Language name :" + object.getLanguage());
   }
}

Salve o código acima como SetMetadata.java e execute-o no prompt de comando -

javac  SetMetadata.java 
java  SetMetadata

A seguir está o conteúdo de Example.txt.

Hi students welcome to tutorialspoint

Se você executar o programa acima, ele fornecerá a seguinte saída -

Language name :en

Junto com o jar Tika, Tika fornece um aplicativo de interface gráfica do usuário (GUI) e um aplicativo de interface de linha de comando (CLI). Você também pode executar um aplicativo Tika a partir do prompt de comando, como outros aplicativos Java.

Interface gráfica do usuário (GUI)

• Tika fornece um arquivo jar junto com seu código-fonte no link a seguir https://tika.apache.org/download.html.

• Baixe ambos os arquivos, defina o classpath para o arquivo jar.

• Extraia a pasta zip do código-fonte e abra a pasta tika-app.

• Na pasta extraída em “tika-1.6 \ tika-app \ src \ main \ java \ org \ apache \ Tika \ gui”, você verá dois arquivos de classe: ParsingTransferHandler.java e TikaGUI.java.

• Compile ambos os arquivos de classe e execute o arquivo de classe TikaGUI.java, ele abre a seguinte janela.

Vamos agora ver como usar a GUI do Tika.

Na GUI, clique em abrir, navegue e selecione um arquivo a ser extraído ou arraste-o para o espaço em branco da janela.

Tika extrai o conteúdo dos arquivos e o exibe em cinco formatos diferentes, viz. metadados, texto formatado, texto simples, conteúdo principal e texto estruturado. Você pode escolher qualquer formato que desejar.

Da mesma forma, você também encontrará a classe CLI na pasta “tika-1.6 \ tikaapp \ src \ main \ java \ org \ apache \ tika \ cli”.

A ilustração a seguir mostra o que Tika pode fazer. Quando colocamos a imagem na GUI, Tika extrai e exibe seus metadados.

A seguir está o programa para extrair conteúdo e metadados de um PDF.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.pdf.PDFParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class PdfParse {

   public static void main(final String[] args) throws IOException,TikaException {

      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("Example.pdf"));
      ParseContext pcontext = new ParseContext();
      
      //parsing the document using PDF parser
      PDFParser pdfparser = new PDFParser(); 
      pdfparser.parse(inputstream, handler, metadata,pcontext);
      
      //getting the content of the document
      System.out.println("Contents of the PDF :" + handler.toString());
      
      //getting metadata of the document
      System.out.println("Metadata of the PDF:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name+ " : " + metadata.get(name));
      }
   }
}

Salve o código acima como PdfParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac PdfParse.java
java PdfParse

Abaixo, está o instantâneo de example.pdf

O PDF que estamos passando tem as seguintes propriedades -

Depois de compilar o programa, você obterá a saída conforme mostrado abaixo.

Output -

Contents of the PDF:

Apache Tika is a framework for content type detection and content extraction 
which was designed by Apache software foundation. It detects and extracts metadata 
and structured text content from different types of documents such as spreadsheets, 
text documents, images or PDFs including audio or video input formats to certain extent.

Metadata of the PDF:

dcterms:modified :     2014-09-28T12:31:16Z
meta:creation-date :     2014-09-28T12:31:16Z
meta:save-date :     2014-09-28T12:31:16Z
dc:creator :     Krishna Kasyap
pdf:PDFVersion :     1.5
Last-Modified :     2014-09-28T12:31:16Z
Author :     Krishna Kasyap
dcterms:created :     2014-09-28T12:31:16Z
date :     2014-09-28T12:31:16Z
modified :     2014-09-28T12:31:16Z
creator :     Krishna Kasyap
xmpTPg:NPages :     1
Creation-Date :     2014-09-28T12:31:16Z
pdf:encrypted :     false
meta:author :     Krishna Kasyap
created :     Sun Sep 28 05:31:16 PDT 2014
dc:format :     application/pdf; version = 1.5
producer :     Microsoft® Word 2013
Content-Type :     application/pdf
xmp:CreatorTool :     Microsoft® Word 2013
Last-Save-Date :     2014-09-28T12:31:16Z

A seguir é fornecido o programa para extrair conteúdo e metadados do Open Office Document Format (ODF).

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.odf.OpenDocumentParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class OpenDocumentParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example_open_document_presentation.odp"));
      ParseContext pcontext = new ParseContext();
      
      //Open Document Parser
      OpenDocumentParser openofficeparser = new OpenDocumentParser (); 
      openofficeparser.parse(inputstream, handler, metadata,pcontext); 
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {		        
         System.out.println(name + " :  " + metadata.get(name)); 
      }
   }
}

Salve o código acima como OpenDocumentParse.java, e compilá-lo no prompt de comando usando os seguintes comandos -

javac OpenDocumentParse.java
java OpenDocumentParse

A seguir, é fornecido um instantâneo do arquivo example_open_document_presentation.odp.

Este documento possui as seguintes propriedades -

Após compilar o programa, você obterá a seguinte saída.

Output -

Contents of the document:

Apache Tika
Apache Tika is a framework for content type detection and content extraction which was designed 
by Apache software foundation. It detects and extracts metadata and structured text content from 
different types of documents such as spreadsheets, text documents, images or PDFs including audio 
or video input formats to certain extent. 

Metadata of the document:

editing-cycles:   4
meta:creation-date:   2009-04-16T11:32:32.86
dcterms:modified:   2014-09-28T07:46:13.03
meta:save-date:   2014-09-28T07:46:13.03
Last-Modified:   2014-09-28T07:46:13.03
dcterms:created:   2009-04-16T11:32:32.86
date:   2014-09-28T07:46:13.03
modified:   2014-09-28T07:46:13.03
nbObject:   36
Edit-Time:   PT32M6S
Creation-Date:   2009-04-16T11:32:32.86
Object-Count:   36
meta:object-count:   36
generator:   OpenOffice/4.1.0$Win32 OpenOffice.org_project/410m18$Build-9764
Content-Type:   application/vnd.oasis.opendocument.presentation
Last-Save-Date:   2014-09-28T07:46:13.03

A seguir é fornecido o programa para extrair conteúdo e metadados de um documento do Microsoft Office.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.microsoft.ooxml.OOXMLParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class MSExcelParse {

   public static void main(final String[] args) throws IOException, TikaException {
      
      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example_msExcel.xlsx"));
      ParseContext pcontext = new ParseContext();
      
      //OOXml parser
      OOXMLParser  msofficeparser = new OOXMLParser (); 
      msofficeparser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como MSExelParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac MSExcelParse.java
java MSExcelParse

Aqui, estamos passando o seguinte arquivo de exemplo do Excel.

O arquivo Excel fornecido tem as seguintes propriedades -

Depois de executar o programa acima, você obterá a seguinte saída.

Output -

Contents of the document:

Sheet1
Name	Age	Designation		Salary
Ramu	50	Manager			50,000
Raheem	40	Assistant manager	40,000
Robert	30	Superviser		30,000
sita	25	Clerk			25,000
sameer	25	Section in-charge	20,000

Metadata of the document:

meta:creation-date:    2006-09-16T00:00:00Z
dcterms:modified:    2014-09-28T15:18:41Z
meta:save-date:    2014-09-28T15:18:41Z
Application-Name:    Microsoft Excel
extended-properties:Company:    
dcterms:created:    2006-09-16T00:00:00Z
Last-Modified:    2014-09-28T15:18:41Z
Application-Version:    15.0300
date:    2014-09-28T15:18:41Z
publisher:    
modified:    2014-09-28T15:18:41Z
Creation-Date:    2006-09-16T00:00:00Z
extended-properties:AppVersion:    15.0300
protected:    false
dc:publisher:    
extended-properties:Application:    Microsoft Excel
Content-Type:    application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
Last-Save-Date:    2014-09-28T15:18:41Z

A seguir está o programa para extrair conteúdo e metadados de um documento de texto -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BodyContentHandler;
import org.apache.tika.parser.txt.TXTParser;

import org.xml.sax.SAXException;

public class TextParser {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example.txt"));
      ParseContext pcontext=new ParseContext();
      
      //Text document parser
      TXTParser  TexTParser = new TXTParser();
      TexTParser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + " : " + metadata.get(name));
      }
   }
}

Salve o código acima como TextParser.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac TextParser.java
java TextParser

A seguir está o instantâneo do arquivo sample.txt -

O documento de texto tem as seguintes propriedades -

Se você executar o programa acima, ele fornecerá a seguinte saída.

Output -

Contents of the document:

At tutorialspoint.com, we strive hard to provide quality tutorials for self-learning 
purpose in the domains of Academics, Information Technology, Management and Computer 
Programming Languages.
The endeavour started by Mohtashim, an AMU alumni, who is the founder and the managing 
director of Tutorials Point (I) Pvt. Ltd. He came up with the website tutorialspoint.com 
in year 2006 with the help of handpicked freelancers, with an array of tutorials for 
computer programming languages.

Metadata of the document:

Content-Encoding:   windows-1252
Content-Type:   text/plain; charset = windows-1252

A seguir é fornecido o programa para extrair conteúdo e metadados de um documento HTML.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.html.HtmlParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class HtmlParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example.html"));
      ParseContext pcontext = new ParseContext();
      
      //Html parser 
      HtmlParser htmlparser = new HtmlParser();
      htmlparser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + ":   " + metadata.get(name));  
      }
   }
}

Salve o código acima como HtmlParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac HtmlParse.java
java HtmlParse

A seguir está o instantâneo do arquivo example.txt.

O documento HTML tem as seguintes propriedades–

Se você executar o programa acima, ele fornecerá a seguinte saída.

Output -

Contents of the document:

	Name	                     Salary	    age
	Ramesh Raman	             50000	    20
	Shabbir Hussein	             70000          25
	Umesh Raman	             50000	    30
	Somesh	                     50000	    35

Metadata of the document:

title:   HTML Table Header
Content-Encoding:   windows-1252
Content-Type:   text/html; charset = windows-1252
dc:title:   HTML Table Header

A seguir está o programa para extrair conteúdo e metadados de um documento XML -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.xml.XMLParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class XmlParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("pom.xml"));
      ParseContext pcontext = new ParseContext();
      
      //Xml parser
      XMLParser xmlparser = new XMLParser(); 
      xmlparser.parse(inputstream, handler, metadata, pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como XmlParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac XmlParse.java
java XmlParse

A seguir está o instantâneo do arquivo example.xml

Este documento possui as seguintes propriedades -

Se você executar o programa acima, ele fornecerá a seguinte saída -

Output -

Contents of the document:
  
4.0.0
org.apache.tika
tika
1.6
org.apache.tika
tika-core
1.6
org.apache.tika
tika-parsers
1.6
src
maven-compiler-plugin
3.1
1.7
1.7

Metadata of the document:

Content-Type:   application/xml

A seguir está o programa para extrair conteúdo e metadados de um arquivo .class.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.asm.ClassParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class JavaClassParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("Example.class"));
      ParseContext pcontext = new ParseContext();

      //Html parser
      ClassParser  ClassParser = new  ClassParser();
      ClassParser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {		        
         System.out.println(name + " :  " + metadata.get(name));  
      }
   }
}

Salve o código acima como JavaClassParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac JavaClassParse.java
java JavaClassParse

A seguir está o instantâneo de Example.java que irá gerar Example.class após a compilação.

Example.class arquivo tem as seguintes propriedades -

Depois de executar o programa acima, você obterá a seguinte saída.

Output -

Contents of the document:

package tutorialspoint.tika.examples;
public synchronized class Example {
   public void Example();
   public static void main(String[]);
}

Metadata of the document:

title: Example
resourceName: Example.class
dc:title: Example

A seguir está o programa para extrair conteúdo e metadados de um arquivo Java Archive (jar) -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.sax.BodyContentHandler;
import org.apache.tika.parser.pkg.PackageParser;

import org.xml.sax.SAXException;

public class PackageParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("Example.jar"));
      ParseContext pcontext = new ParseContext();
      
      //Package parser
      PackageParser packageparser = new PackageParser();
      packageparser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document: " + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + ":   " + metadata.get(name));
      }
   }
}

Salve o código acima como PackageParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac PackageParse.java
java PackageParse

A seguir está o instantâneo de Example.java que reside dentro do pacote.

O arquivo jar tem as seguintes propriedades -

Depois de executar o programa acima, ele fornecerá a seguinte saída -

Output -

Contents of the document:

META-INF/MANIFEST.MF
tutorialspoint/tika/examples/Example.class

Metadata of the document:

Content-Type:   application/zip

A seguir é fornecido o programa para extrair conteúdo e metadados de uma imagem JPEG.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.jpeg.JpegParser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class JpegParse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("boy.jpg"));
      ParseContext pcontext = new ParseContext();
      
      //Jpeg Parse
      JpegParser  JpegParser = new JpegParser();
      JpegParser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) { 		        
         System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como JpegParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac JpegParse.java
java JpegParse

A seguir está o instantâneo de Example.jpeg -

O arquivo JPEG tem as seguintes propriedades -

Depois de executar o programa, você obterá a seguinte saída.

Output −

Contents of the document:

Meta data of the document:

Resolution Units: inch
Compression Type: Baseline
Data Precision: 8 bits
Number of Components: 3
tiff:ImageLength: 3000
Component 2: Cb component: Quantization table 1, Sampling factors 1 horiz/1 vert
Component 1: Y component: Quantization table 0, Sampling factors 2 horiz/2 vert
Image Height: 3000 pixels
X Resolution: 300 dots
Original Transmission Reference: 53616c7465645f5f2368da84ca932841b336ac1a49edb1a93fae938b8db2cb3ec9cc4dc28d7383f1
Image Width: 4000 pixels
IPTC-NAA record: 92 bytes binary data
Component 3: Cr component: Quantization table 1, Sampling factors 1 horiz/1 vert
tiff:BitsPerSample: 8
Application Record Version: 4
tiff:ImageWidth: 4000
Y Resolution: 300 dots

A seguir está o programa para extrair conteúdo e metadados de arquivos MP4 -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.mp4.MP4Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class Mp4Parse {

   public static void main(final String[] args) throws IOException,SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example.mp4"));
      ParseContext pcontext = new ParseContext();
      
      //Html parser
      MP4Parser MP4Parser = new MP4Parser();
      MP4Parser.parse(inputstream, handler, metadata,pcontext);
      System.out.println("Contents of the document:  :" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();
      
      for(String name : metadataNames) {
         System.out.println(name + ": " + metadata.get(name));
      }
   }  
}

Salve o código acima como JpegParse.java e compile-o no prompt de comando usando os seguintes comandos -

javac Mp4Parse.java
java Mp4Parse

A seguir está o instantâneo das propriedades do arquivo Example.mp4.

Depois de executar o programa acima, você obterá a seguinte saída -

Output -

Contents of the document:

Metadata of the document:

dcterms:modified: 2014-01-06T12:10:27Z
meta:creation-date: 1904-01-01T00:00:00Z
meta:save-date: 2014-01-06T12:10:27Z
Last-Modified: 2014-01-06T12:10:27Z
dcterms:created: 1904-01-01T00:00:00Z
date: 2014-01-06T12:10:27Z
tiff:ImageLength: 360
modified: 2014-01-06T12:10:27Z
Creation-Date: 1904-01-01T00:00:00Z
tiff:ImageWidth: 640
Content-Type: video/mp4
Last-Save-Date: 2014-01-06T12:10:27Z

A seguir está o programa para extrair conteúdo e metadados de arquivos mp3 -

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.mp3.LyricsHandler;
import org.apache.tika.parser.mp3.Mp3Parser;
import org.apache.tika.sax.BodyContentHandler;

import org.xml.sax.SAXException;

public class Mp3Parse {

   public static void main(final String[] args) throws Exception, IOException, SAXException, TikaException {

      //detecting the file type
      BodyContentHandler handler = new BodyContentHandler();
      Metadata metadata = new Metadata();
      FileInputStream inputstream = new FileInputStream(new File("example.mp3"));
      ParseContext pcontext = new ParseContext();
      
      //Mp3 parser
      Mp3Parser  Mp3Parser = new  Mp3Parser();
      Mp3Parser.parse(inputstream, handler, metadata, pcontext);
      LyricsHandler lyrics = new LyricsHandler(inputstream,handler);
      
      while(lyrics.hasLyrics()) {
    	  System.out.println(lyrics.toString());
      }
      
      System.out.println("Contents of the document:" + handler.toString());
      System.out.println("Metadata of the document:");
      String[] metadataNames = metadata.names();

      for(String name : metadataNames) {		        
    	  System.out.println(name + ": " + metadata.get(name));
      }
   }
}

Salve o código acima como JpegParse.java, e compilá-lo a partir do prompt de comando usando os seguintes comandos -

javac Mp3Parse.java
java Mp3Parse

O arquivo example.mp3 tem as seguintes propriedades -

Você obterá a seguinte saída após executar o programa. Se o arquivo fornecido tiver alguma letra, nosso aplicativo irá capturar e exibir junto com a saída.

Output -

Contents of the document:

Kanulanu Thaake
Arijit Singh
Manam (2014), track 01/06
2014
Soundtrack
30171.65
eng - 
DRGM
Arijit Singh
Manam (2014), track 01/06
2014
Soundtrack
30171.65
eng - 
DRGM

Metadata of the document:

xmpDM:releaseDate: 2014
xmpDM:duration: 30171.650390625
xmpDM:audioChannelType: Stereo
dc:creator: Arijit Singh
xmpDM:album: Manam (2014)
Author: Arijit Singh
xmpDM:artist: Arijit Singh
channels: 2
xmpDM:audioSampleRate: 44100
xmpDM:logComment: eng - 
DRGM
xmpDM:trackNumber: 01/06
version: MPEG 3 Layer III Version 1
creator: Arijit Singh
xmpDM:composer: Music : Anoop Rubens | Lyrics : Vanamali
xmpDM:audioCompressor: MP3
title: Kanulanu Thaake
samplerate: 44100
meta:author: Arijit Singh
xmpDM:genre: Soundtrack
Content-Type: audio/mpeg
xmpDM:albumArtist: Manam (2014)
dc:title: Kanulanu Thaake