Java 使用MongoDB实现hibernate搜索的目录提供程序

我想在Heroku上为我的站点使用这个解决方案，这样我就可以使用MongoDB进行索引。有谁知道一本好的教程或书籍可以提供一个深入的例子来说明如何做到这一点吗？谷歌搜索并没有给我带来任何好处

---

谢谢。

如果您想帮助实现它（我的意思是创建Java代码以支持此配置），请加入更合适的邮件列表中的对话：

在此处订阅：

---

集成一些现有组件应该是直截了当的编码。

如果您想帮助实现它（我的意思是创建Java代码以支持此配置），请在更合适的邮件列表中加入对话：

在此处订阅：

---

集成一些现有组件应该是直截了当的编码。

我花了很长时间在这方面，因为我对Mongo DB非常陌生，直到它看起来是Heroku上搜索实现的一个好解决方案，我才打算使用它。我想我会加上这个答案来帮助其他想做同样事情的人

我使用了lucene mongo db项目的代码，该项目位于：

然后创建了我自己的hibernate搜索目录提供程序类，该类与lucene mongo db项目接口。我使用org.hibernate.search.store.impl.RAMDirectoryProvider类作为要遵循的大纲

剩下要做的就是让hibernate配置指向新类：

hibernate.search.default.directory_provider=com.foo.MongoLuceneDirectoryProvider

这是我的蒙古诺董事课程：

package com.foo.MongoLuceneDirectoryProvider

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.Properties;
import java.util.concurrent.ConcurrentMap;

import org.apache.log4j.Logger;
import org.apache.lucene.store.Directory;
import org.hibernate.search.SearchException;
import org.hibernate.search.indexes.impl.DirectoryBasedIndexManager;
import org.hibernate.search.spi.BuildContext;
import org.hibernate.search.store.DirectoryProvider;
import org.hibernate.search.store.impl.DirectoryProviderHelper;

import com.github.mongoutils.collections.DBObjectSerializer;
import com.github.mongoutils.collections.MongoConcurrentMap;
import com.github.mongoutils.collections.SimpleFieldDBObjectSerializer;
import com.github.mongoutils.lucene.MapDirectory;
import com.github.mongoutils.lucene.MapDirectoryEntry;
import com.github.mongoutils.lucene.MapDirectoryEntrySerializer;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

public class MongoLuceneDirectoryProvider implements DirectoryProvider<Directory> {

    private Logger log = Logger.getLogger(MongoLuceneDirectoryProvider.class);

    private Directory directory;

    private String indexName;
    private Properties properties;

    @Override
    public void initialize(String directoryProviderName, Properties properties, BuildContext context) {

            indexName = directoryProviderName;
        this.properties = properties;

        Mongo mongo;

        try {
            mongo = new Mongo("localhost");

            DB db = mongo.getDB("testdb");
            DBCollection dbCollection = db.getCollection("testcollection");

            DBObjectSerializer<String> keySerializer = new SimpleFieldDBObjectSerializer<String>("key");
            DBObjectSerializer<MapDirectoryEntry> valueSerializer = new MapDirectoryEntrySerializer("value");
            ConcurrentMap<String, MapDirectoryEntry> store = new MongoConcurrentMap<String, MapDirectoryEntry>(dbCollection, keySerializer, valueSerializer);

            directory = new MapDirectory(store);
        }
        catch (UnknownHostException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
        catch (MongoException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
        catch (IOException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
    }

    @Override
    public void start(DirectoryBasedIndexManager indexManager) {

        try {
            directory.setLockFactory(DirectoryProviderHelper.createLockFactory(null, properties));
            properties = null;
            DirectoryProviderHelper.initializeIndexIfNeeded(directory);
        }
        catch (IOException e) {
            throw new SearchException("Unable to initialize index: " + indexName, e);
        }
    }

    @Override
    public void stop() {

        try {
            directory.close();
        }
        catch (IOException e) {
            log.error("While attempting to stop directory provider", e);
        }
    }

    @Override
    public Directory getDirectory() { return this.directory; }

}

package com.foo.monguucedDirectoryProvider
导入java.io.IOException；
导入java.net.UnknownHostException；
导入java.util.Properties；
导入java.util.concurrent.ConcurrentMap；
导入org.apache.log4j.Logger；
导入org.apache.lucene.store.Directory；
导入org.hibernate.search.SearchException；
导入org.hibernate.search.index.impl.DirectoryBasedIndexManager；
导入org.hibernate.search.spi.BuildContext；
导入org.hibernate.search.store.DirectoryProvider；
导入org.hibernate.search.store.impl.DirectoryProviderHelper；
导入com.github.mongoutils.collections.DBObjectSerializer；
导入com.github.mongoutils.collections.MongoConcurrentMap；
导入com.github.mongoutils.collections.SimpleFieldDBObjectSerializer；
导入com.github.mongoutils.lucene.MapDirectory；
导入com.github.mongoutils.lucene.MapDirectoryEntry；
导入com.github.mongoutils.lucene.MapDirectoryEntrySerializer；
导入com.mongodb.DB；
导入com.mongodb.DBCollection；
导入com.mongodb.Mongo；
导入com.mongodb.MongoException；
公共类MonguucedDirectoryProvider实现DirectoryProvider{
私有记录器log=Logger.getLogger（monguucedirectoryprovider.class）；
专用目录；
私有字符串indexName；
私人物业;；
@凌驾
public void initialize（字符串directoryProviderName、属性、BuildContext上下文）{
indexName=目录提供者名称；
这个。属性=属性；
蒙戈·蒙戈；
试一试{
mongo=新的mongo（“本地主机”）；
DB=mongo.getDB（“testdb”）；
DBCollection DBCollection=db.getCollection（“testcollection”）；
DBObjectSerializer keySerializer=新的SimpleFieldDBObjectSerializer（“键”）；
DBObjectSerializer valueSerializer=新的MapDirectoryEntrySerializer（“值”）；
ConcurrentMap存储=新的MongoConcurrentMap（dbCollection、keySerializer、valueSerializer）；
目录=新映射目录（存储）；
}
捕获（未知后异常e）{
log.error（“尝试初始化Mongo目录提供程序时”，e）；
}
捕获（MongoException e）{
log.error（“尝试初始化Mongo目录提供程序时”，e）；
}
捕获（IOE异常）{
log.error（“尝试初始化Mongo目录提供程序时”，e）；
}
}
@凌驾
public void start（DirectoryBasedIndexManager索引管理器）{
试一试{
setLockFactory（DirectoryProviderHelper.createLockFactory（null，properties））；
属性=null；
DirectoryProviderHelper.InitializeIndexIfNeed（目录）；
}
捕获（IOE异常）{
抛出新的SearchException（“无法初始化索引：+indexName，e”）；
}
}
@凌驾
公共停车场（）{
试一试{
close（）目录；
}
捕获（IOE异常）{
log.error（“试图停止目录提供程序时”，e）；
}
}
@凌驾
公用目录getDirectory（）{返回this.Directory；}
}

我花了很长时间在这上面，因为我对Mongo DB太陌生了，在它看起来是Heroku上搜索实现的一个好解决方案之前，我还没有打算使用它。我想我会加上这个答案来帮助其他想做同样事情的人

我使用了lucene mongo db项目的代码，该项目位于：

然后创建了我自己的hibernate搜索目录提供程序类，该类与lucene mongo db项目接口。我使用org.hibernate.search.store.impl.RAMDirectoryProvider类作为要遵循的大纲

剩下要做的就是让hibernate配置指向新类：

hibernate.search.default.directory_provider=com.foo.MongoLuceneDirectoryProvider

这是我的蒙古诺董事课程：

package com.foo.MongoLuceneDirectoryProvider

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.Properties;
import java.util.concurrent.ConcurrentMap;

import org.apache.log4j.Logger;
import org.apache.lucene.store.Directory;
import org.hibernate.search.SearchException;
import org.hibernate.search.indexes.impl.DirectoryBasedIndexManager;
import org.hibernate.search.spi.BuildContext;
import org.hibernate.search.store.DirectoryProvider;
import org.hibernate.search.store.impl.DirectoryProviderHelper;

import com.github.mongoutils.collections.DBObjectSerializer;
import com.github.mongoutils.collections.MongoConcurrentMap;
import com.github.mongoutils.collections.SimpleFieldDBObjectSerializer;
import com.github.mongoutils.lucene.MapDirectory;
import com.github.mongoutils.lucene.MapDirectoryEntry;
import com.github.mongoutils.lucene.MapDirectoryEntrySerializer;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

public class MongoLuceneDirectoryProvider implements DirectoryProvider<Directory> {

    private Logger log = Logger.getLogger(MongoLuceneDirectoryProvider.class);

    private Directory directory;

    private String indexName;
    private Properties properties;

    @Override
    public void initialize(String directoryProviderName, Properties properties, BuildContext context) {

            indexName = directoryProviderName;
        this.properties = properties;

        Mongo mongo;

        try {
            mongo = new Mongo("localhost");

            DB db = mongo.getDB("testdb");
            DBCollection dbCollection = db.getCollection("testcollection");

            DBObjectSerializer<String> keySerializer = new SimpleFieldDBObjectSerializer<String>("key");
            DBObjectSerializer<MapDirectoryEntry> valueSerializer = new MapDirectoryEntrySerializer("value");
            ConcurrentMap<String, MapDirectoryEntry> store = new MongoConcurrentMap<String, MapDirectoryEntry>(dbCollection, keySerializer, valueSerializer);

            directory = new MapDirectory(store);
        }
        catch (UnknownHostException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
        catch (MongoException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
        catch (IOException e) {
            log.error("While attempting to initalize Mongo directory provider", e);
        }
    }

    @Override
    public void start(DirectoryBasedIndexManager indexManager) {

        try {
            directory.setLockFactory(DirectoryProviderHelper.createLockFactory(null, properties));
            properties = null;
            DirectoryProviderHelper.initializeIndexIfNeeded(directory);
        }
        catch (IOException e) {
            throw new SearchException("Unable to initialize index: " + indexName, e);
        }
    }

    @Override
    public void stop() {

        try {
            directory.close();
        }
        catch (IOException e) {
            log.error("While attempting to stop directory provider", e);
        }
    }

    @Override
    public Directory getDirectory() { return this.directory; }

}

package com.foo.monguucedDirectoryProvider
导入java.io.IOException；
导入java.net.UnknownHostException；
导入java.util.Properties；
导入java.util.concurrent.ConcurrentMap；
导入org.apache.log4j.Logger；
导入org.apache.lucene.store.Directory；
导入org.hibernate.search.SearchException；
导入org.hibernate.search.index.impl.DirectoryBasedIndexManager；
导入org.hibernate.search.spi.BuildContext；
导入org.hibernate.search.store.DirectoryProvider；
导入org.hibernate.search.store.impl.DirectoryProviderHelper；
重要的