logger.debug("Indexing " + file);
try {
	Document doc = null;
	// parse the document
	synchronized (contentParserAccess) {
		doc = contentParser.getDocument(file);
	}
 
	// put it into Lucene
	if (doc != null) {
		writer.addDocument(doc);
	} else {
		logger.error("Cannot handle "
				+ file.getAbsolutePath() + "; skipping");
	}
} catch (IOException e) {
	logger.error("Cannot index " + file.getAbsolutePath()
			+ "; skipping (" + e.getMessage() + ")");
}

package de.acidum.indexer.tika.parser;
 
import ...
 
/**
*
* This class the is the bridge between Lucene and Tika. It uses Tika to
* retrieve the file content and metadata and generates a Lucene document.
*
* @author Christoph Hartmann
*
*/
public class TikaDocumentParser implements ContentParser {
 
Logger logger = Logger.getLogger(this.getClass());
 
AutoDetectParser autoDetectParser;
TikaConfig config;
 
public TikaDocumentParser() {
	try {
		// load tika config to replace the image parser with our own
		InputStream is = this.getClass().getClassLoader()
				.getResourceAsStream("tika-config.xml");
		config = new TikaConfig(is);
 
		// use tika's auto detect parser
		autoDetectParser = new AutoDetectParser(config);
	} catch (Exception e) {
		logger.error(e);
	}
}
 
private Document getDocument(InputStream input, MimeType mimeType)
		throws ContentParserException {
	Document doc = null;
	try {
		Metadata metadata = new Metadata();
 
		if (mimeType != null) {
			metadata.set(Metadata.CONTENT_TYPE, mimeType.getName());
		}
		ContentHandler handler = new BodyContentHandler();
		try {
			autoDetectParser.parse(input, handler, metadata);
		} catch (Exception e) {
			throw new ContentParserException(e);
		}
 
		doc = new Document();
		// add the content to lucene index document
		doc.add(new Field("body", handler.toString(), Field.Store.NO,
				Field.Index.ANALYZED));
 
		// add meta data
		String[] names = metadata.names();
		for (String name : names) {
			String value = metadata.get(name);
			doc.add(new Field(name, value, Field.Store.YES,
					Field.Index.ANALYZED));
		}
 
	} finally {
		try {
			input.close();
		} catch (IOException e) {
			throw new ContentParserException(e);
		}
	}
 
	return doc;
}
 
public Document getDocument(File file) throws ContentParserException {
 
	InputStream input;
	try {
		input = new FileInputStream(file);
 
		if (input == null) {
			System.out
					.println("Could not open stream from specified resource: "
							+ file.getName());
		}
 
		Document doc = getDocument(input);
 
		// add the file name to the meta data
		if (doc != null) {
			try {
				doc.add(new Field("filename", file.getCanonicalPath(),
						Field.Store.YES, Field.Index.NO));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
 
		return doc;
 
	} catch (FileNotFoundException e) {
		throw new ContentParserException(e);
	}
 
}
 
public Document getDocument(InputStream input)
		throws ContentParserException {
 
	// try to retrieve the mime type... unfortunately the Tika parser don't
	// handle this automatically
 
	BufferedInputStream bufIn = new BufferedInputStream(input);
 
	MimeType mimeType = null;
 
	if (bufIn.markSupported()) {
		// TODO this may be dangerous...
		bufIn.mark(2048);
		MimeTypes repo = config.getMimeRepository();
		try {
			mimeType = repo.getMimeType(bufIn);
		} catch (IOException e) {
			throw new ContentParserException(e);
		}
		try {
			bufIn.reset();
		} catch (IOException e) {
			logger.error(e);
		}
	}
 
	Document doc = getDocument(bufIn, mimeType);
 
	return doc;
}
 
}

package de.acidum.tika;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
 
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
 
import org.apache.commons.io.input.CloseShieldInputStream;
import org.apache.log4j.Logger;
import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.Parser;
import org.apache.tika.sax.XHTMLContentHandler;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
 
import com.drew.imaging.jpeg.JpegMetadataReader;
import com.drew.imaging.jpeg.JpegProcessingException;
import com.drew.metadata.Directory;
import com.drew.metadata.MetadataException;
import com.drew.metadata.Tag;
 
/**
* This class implements a tika parser. To activate the parser we have to change
* the tika-config.xml.
*
* Compared to the default Tika Image handling we read the Jpeg Exif data and
* return these values as metadata for Lucene
*
* @author Christoph Hartmann
*
*/
public class ImageParser implements Parser {
 
Logger logger = Logger.getLogger(this.getClass());
 
public void parse(InputStream stream, ContentHandler handler,
		Metadata metadata) throws IOException, SAXException, TikaException {
 
	String type = metadata.get(Metadata.CONTENT_TYPE);
 
	if (type != null) {
		// hey we get a jpeg lets read the exif
		if (type.equals("image/jpeg")) {
			extractJPEGMetaData(stream, metadata);
		}
		// if picture is unknown do the default tika handling
		else {
 
			Iterator<ImageReader> iterator = ImageIO
					.getImageReadersByMIMEType(type);
			if (iterator.hasNext()) {
				ImageReader reader = iterator.next();
				reader.setInput(ImageIO
						.createImageInputStream(new CloseShieldInputStream(
								stream)));
				metadata.set("height", Integer
						.toString(reader.getHeight(0)));
				metadata.set("width", Integer.toString(reader.getWidth(0)));
				reader.dispose();
			}
		}
	}
 
	XHTMLContentHandler xhtml = new XHTMLContentHandler(handler, metadata);
	xhtml.startDocument();
	xhtml.endDocument();
}
 
/**
 * get additional metadata for jpeg files
 *
 * @param inputStream
 * @param tikaMetaData
 */
private void extractJPEGMetaData(InputStream inputStream,
		Metadata tikaMetaData) {
 
	// read the exif meta data
	com.drew.metadata.Metadata jpegMetaData;
	try {
		jpegMetaData = JpegMetadataReader.readMetadata(inputStream);
 
		// iterate through metadata directories
		Iterator<?> directories = jpegMetaData.getDirectoryIterator();
		while (directories.hasNext()) {
			Directory directory = (Directory) directories.next();
			// iterate through tags and print to System.out
			Iterator<?> tags = directory.getTagIterator();
			while (tags.hasNext()) {
				Tag tag = (Tag) tags.next();
 
				try {
					tikaMetaData.set(tag.getDirectoryName() + "."
							+ tag.getTagName(), tag.getDescription());
					logger.debug(tag.getDirectoryName() + "."
							+ tag.getTagName() + " -> "
							+ tag.getDescription());
				} catch (MetadataException e) {
					logger.error(e);
				}
			}
		}
 
	} catch (JpegProcessingException e) {
		logger.error(e);
	}
}
}