Regrouper les résultats de la recherche en utilisant GroupingSearch
Package org.apache.lucene.search.grouping Description
Ce module peut regrouper les résultats de recherche de Lucene et les champs spécifiés à valeur unique sont rassemblés. Par exemple, le groupe selon le champ "Auteur", les documents avec la même valeur de champ "auteur" sont divisés en groupe.
Lors du regroupement, vous devez saisir certaines informations nécessaires:
1. Groupfield: Groupe selon ce domaine. Par exemple, si vous utilisez le champ "Auteur" pour vous regrouper, les livres de chaque groupe sont le même auteur. Les documents sans ce domaine seront divisés en un groupe séparé.
2. Groupes de groupes: tri de groupe.
3. Topngroups: combien de groupes sont conservés. Par exemple, 10 signifie que seuls les 10 premiers groupes sont conservés.
4. GroupOffset: Recherche pour quels groupes de groupes sont classés en premier. Par exemple, 3 signifie renvoyer 7 groupes (en supposant que les opngroups égaux à 10). Il est très utile dans la pagination, comme seuls 5 groupes sont affichés par page.
5. Avec-BoupSort: trier les documents en groupes. Remarque: la différence entre ici et les groupes de groupes
6. WithGroupOffset: Recherche pour quels documents classés d'abord dans chaque groupe.
Le regroupement des résultats de recherche est plus simple à utiliser GroupingSearch
Documentation de l'API de la recherche GroupingingSearch:
Classe de commodité pour effectuer le regroupement dans un environnement non distribué.
Regroupement dans des environnements non distribués
Avertissement: cette API est expérimentale et pourrait changer de manière incompatible dans la prochaine version.
La version 4.3.1 est utilisée ici
Quelques façons importantes:
Exemple de code:
1. Regardez d'abord le code index
Classe publique IndexHelper {document de document privé; répertoire privé; Index IndexWriter privé; Répertoire public getDirectory () {répertoire = (répertoire == null)? Nouveau Ramdirectory (): répertoire; répertoire de retour; } private indexWriterConfig getConfig () {return new IndexWriterConfig (version.lucene_43, new ikanalyzer (true)); } private indexwriter getIndexWriter () {try {return new IndexWriter (getDirectory (), getConfig ()); } catch (ioException e) {e.printStackTrace (); retourner null; }} public indexSearcher getIndexSearcher () lève ioException {return new IndexSearcher (DirectoryReader.Open (getDirectory ())); } / ** * Créer un index pour le test de groupe * @param auteur * @param Content * / public void createIndexForGroup (int id, string auteur, string contenu) {indexWriter = getIndexWriter (); document = nouveau document (); document.add (new intField ("id", id, field.store.oes)); document.add (new Stringfield ("auteur", auteur, field.store.oes)); Document.Add (new TextField ("Content", Content, Field.Store.oi)); try {indexWriter.addDocument (document); indexWriter.Commit (); indexWriter.Close (); } catch (ioException e) {e.printStackTrace (); }}}2. Groupement:
Classe publique GroupTestPublic Void Group (IndexSearcher IndexSearcher, String GroupField, String Content) lève IoException, ParseException {GroupingSearch GroupingSearch = new GroupingSearch (GroupField); GroupingSearch.setGroupSort (nouveau tri (sortfield.field_score)); GroupingSearch.setFillSortFields (true); GroupingSearch.setCachingInmb (4.0, true); GroupingSearch.SetAllGroups (true); //GroupingSearch.setAllGroupheads(True); GroupingSearch.SetGroupDocslimit (10); QueryParser parser = new queryParser (version.lucene_43, "contenu", new ikanalyzer (true)); Query Query = Parser.Parse (Contenu); Topgroups <y bytesRef> result = groupingSearch.search (indexSearcher, query, 0, 1000); System.out.println ("Search Hits:" + result.totalHitCount); System.out.println ("Recherche Recherche Résultat:" + result.groups.length); Document de document; for (groupDocs <yTesResRef> GroupDocs: result.groups) {System.out.println ("Group:" + GroupDocs.GroupValue.Utf8ToString ()); System.out.println ("Enregistrement en groupe:" + GroupDocs.TotalHits); //System.out.println("GroupDocs.scoreocs.length: "+ groupDocs.scoreocs.Length); for (scoreOC scoreoc: groupDocs.scoreocs) {System.out.println (indexSearcher.doc (scoretoc.doc)); }}}3. Test simple:
public static void main (String [] args) lève ioException, parseException {indexHelper indexHelper = new IndexHelper (); IndexHelper.CreateIndexForGroup (1, "Patate douce", "Chine open source"); IndexHelper.CreateIndexForGroup (2, "Sweet Potato", "Open Source Community"); indexHelper.CreateIndexForGroup (3, "Patate douce", "Code Design"); IndexHelper.CreateIndexForGroup (4, "Patate douce", "Design"); indexHelper.CreateIndexForGroup (5, "Jiexian", "Lucene Development"); indexHelper.CreateIndexForGroup (6, "jiexian", "lunene pratique combat"); indexHelper.CreateIndexForGroup (7, "Jiexian", "Open Source Lucene"); indexHelper.CreateIndexForGroup (8, "jiexian", "open source solr"); IndexHelper.CreateIndexForGroup (9, "Sanxian", "Sanxian Open Source Lucene"); indexHelper.CreateIndexForGroup (10, "Sanxian", "Sanxian Open Source Solr"); indexHelper.CreateIndexForGroup (11, "Sanxian", "open source"); Groupest Grouptest = New Grouptest (); grouptest.group (indexhelper.getIndexSearcher (), "auteur", "open source"); }} 4. Résultats des tests:
Deux façons de paginer
Lucene a deux façons de paginer:
1. Paginez directement les résultats de la recherche. Cette méthode peut être utilisée lorsque le volume de données est relativement faible. La référence principale du code de pagination est:
SCOREDOC [] SD = XXX; // Query Démarrer la position de l'enregistrement int début = PageSize * (CurrentPage - 1); // terminer la position de l'enregistrement Int end = math.min (Begin + PageSize, sd.length); for (int i = begin; i <end && i <totalhits; i ++) {// code pour le traitement des données de recherche}}2. Utilisez Searchafter (...)
Lucene fournit cinq méthodes de surcharge qui peuvent être utilisées au besoin
Score après: réduire la quantité totale de score pour le dernier résultat de recherche de 1;
Requête de requête: méthode de requête
INT N: le nombre de résultats renvoyés pour chaque requête, c'est-à-dire le nombre total de résultats par page
Un exemple simple d'utilisation:
// Vous pouvez utiliser MAP pour enregistrer la carte de recherche de recherche nécessaire <String, objet> resultMap = new HashMap <String, Object> (); ScoreC after = NULL; Query Query = xxtOpDocs td = search.searchafter (After, Query, Size); // Get Hit Number resultMap.put ("num", td.totalhits); SCOREDOC [] SD = TD.SCOREDOCS; for (scoreoc scoreoc: sd) {// Traitement de résultats de recherche classique} // Résultats de la recherche La quantité totale du score est réduite de 1 après = sd [td.scoreocs.length - 1]; // Enregistrer après la recherche suivante, c'est-à-dire que la page suivante démarre le resultMap.put ("après", après); return resultMap;