0001: /*
0002: * LIUS - Lucene Index Update and Search
0003: * http://sourceforge.net/projects/lius/
0004: *
0005: * Copyright (c) 2005, Laval University Library. All rights reserved.
0006: *
0007: * This library is free software; you can redistribute it and/or
0008: * modify it under the terms of the GNU Lesser General Public
0009: * License as published by the Free Software Foundation; either
0010: * version 2.1 of the License, or (at your option) any later version.
0011: *
0012: * This library is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0015: * Lesser General Public License for more details.
0016: *
0017: * You should have received a copy of the GNU Lesser General Public
0018: * License along with this library; if not, write to the Free Software
0019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
0020: */
0021:
0022: package ca.ulaval.bibl.lius.search;
0023:
0024: import java.io.IOException;
0025: import java.io.StringReader;
0026: import java.util.ArrayList;
0027: import java.util.List;
0028: import java.util.Vector;
0029:
0030: import org.apache.log4j.Logger;
0031: import org.apache.lucene.analysis.Analyzer;
0032: import org.apache.lucene.analysis.TokenStream;
0033: import org.apache.lucene.index.IndexReader;
0034: import org.apache.lucene.index.MultiReader;
0035: import org.apache.lucene.search.Hits;
0036: import org.apache.lucene.search.IndexSearcher;
0037: import org.apache.lucene.search.MultiSearcher;
0038: import org.apache.lucene.search.Query;
0039: import org.apache.lucene.search.Searchable;
0040: import org.apache.lucene.search.Searcher;
0041: import org.apache.lucene.search.highlight.Fragmenter;
0042: import org.apache.lucene.search.highlight.Highlighter;
0043: import org.apache.lucene.search.highlight.QueryScorer;
0044: import org.apache.lucene.search.highlight.SimpleFragmenter;
0045: import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
0046: import org.apache.lucene.store.Directory;
0047: import org.apache.lucene.store.FSDirectory;
0048: import org.jdom.Attribute;
0049: import org.jdom.Document;
0050: import org.jdom.Element;
0051: import org.jdom.JDOMException;
0052: import org.jdom.input.SAXBuilder;
0053: import org.jdom.output.DOMOutputter;
0054:
0055: import ca.ulaval.bibl.lius.Lucene.AnalyzerFactory;
0056: import ca.ulaval.bibl.lius.Lucene.LuceneActions;
0057: import ca.ulaval.bibl.lius.config.LiusConfig;
0058: import ca.ulaval.bibl.lius.config.LiusConfigBuilder;
0059: import ca.ulaval.bibl.lius.config.LiusField;
0060:
0061: /**
0062: *
0063: * Classe permettant d'effectuer des recherches au niveau de l'index.
0064: *
0065: * <br/><br/>
0066: *
0067: * Class that enables searches on the index.
0068: *
0069: * @author Rida Benjelloun (rida.benjelloun@bibl.ulaval.ca)
0070: *
0071: */
0072:
0073: public class SearchIndex {
0074:
0075: //private static SearchIndex searchActIns;
0076:
0077: private Searcher searcher = null;
0078:
0079: private Searchable[] searchables = null;
0080:
0081: private LiusQuery lq = new LiusQuery();
0082:
0083: static Logger logger = Logger.getRootLogger();
0084:
0085: /**
0086: *
0087: * Méthode se basant sur le fichier XML de configuration afin de
0088: *
0089: * construire l'analyseur et l'objet Query.
0090: *
0091: * Elle reçoit également le chemin de l'index et une expression de
0092: *
0093: * recherche entrée par l'utilisateur.
0094: *
0095: * <br/><br/>
0096: *
0097: * Method based on the XML configuration file to construct the
0098: *
0099: * analyser et the Query object. The method needs the path of the index and
0100: * a
0101: *
0102: * search expression given by a user.
0103: *
0104: */
0105:
0106: public synchronized List search(String rechercheExp,
0107:
0108: String indexDir,
0109:
0110: String configFile) {
0111:
0112: List liusHits = new ArrayList();
0113:
0114: Directory fsDir = null;
0115:
0116: Fragmenter fragmenter = null;
0117:
0118: String fragment = null;
0119:
0120: Vector values = null;
0121:
0122: QueryScorer scorer = null;
0123:
0124: SimpleHTMLFormatter formatter = null;
0125:
0126: Highlighter highlighter = null;
0127:
0128: try {
0129:
0130: LiusConfig xc = LiusConfigBuilder.getSingletonInstance().
0131:
0132: getLiusConfig(configFile);
0133:
0134: if (LuceneActions.getSingletonInstance().indexExists(
0135: indexDir)) {
0136:
0137: fsDir = FSDirectory.getDirectory(indexDir, false);
0138:
0139: }
0140:
0141: searcher = new IndexSearcher(fsDir);
0142:
0143: Query query = lq.getQueryFactory(xc.
0144:
0145: getElemSearch(),
0146:
0147: xc, rechercheExp);
0148:
0149: Hits hits = searcher.search(query);
0150:
0151: if (xc.getHighlighter() == true) {
0152:
0153: scorer = new QueryScorer(query.rewrite(IndexReader
0154: .open(
0155:
0156: fsDir)));
0157:
0158: formatter =
0159:
0160: new SimpleHTMLFormatter("<span class=\"liusHit\">",
0161: "</span>");
0162:
0163: highlighter = new Highlighter(formatter, scorer);
0164:
0165: }
0166:
0167: Vector fieldsToDisplay = xc.getDisplayFields();
0168:
0169: for (int i = 0; i < hits.length(); i++) {
0170:
0171: List document = new ArrayList();
0172:
0173: for (int j = 0; j < fieldsToDisplay.size(); j++) {
0174:
0175: LiusField lf = (LiusField) fieldsToDisplay.get(j);
0176:
0177: if (xc.getHighlighter() == true) {
0178:
0179: if (lf.getFragmenter() != null) {
0180:
0181: fragmenter = new SimpleFragmenter(Integer
0182: .parseInt(lf.
0183:
0184: getFragmenter()));
0185:
0186: }
0187:
0188: else {
0189:
0190: fragmenter = new SimpleFragmenter(
0191: Integer.MAX_VALUE);
0192:
0193: }
0194:
0195: highlighter.setTextFragmenter(fragmenter);
0196:
0197: }
0198:
0199: LiusField lfNew = new LiusField();
0200:
0201: String fieldName = lf.getName();
0202:
0203: lfNew.setName(fieldName);
0204:
0205: lfNew.setLabel(lf.getLabel());
0206:
0207: String[] valS = hits.doc(i).getValues(fieldName);
0208:
0209: values = new Vector();
0210:
0211: if (valS != null) {
0212:
0213: for (int k = 0; k < valS.length; k++) {
0214:
0215: if (xc.getHighlighter() == true) {
0216:
0217: TokenStream stream = ((Analyzer) AnalyzerFactory
0218: .getAnalyzer(
0219:
0220: xc)).
0221:
0222: tokenStream(lf.getName(),
0223:
0224: new StringReader(valS[k]));
0225:
0226: if (lf.getFragmenter() != null)
0227:
0228: fragment = highlighter
0229: .getBestFragments(stream,
0230: valS[k], 5,
0231:
0232: "...");
0233:
0234: else {
0235:
0236: fragment = highlighter
0237: .getBestFragment(stream,
0238: valS[k]);
0239:
0240: }
0241:
0242: }
0243:
0244: if (fragment == null) {
0245:
0246: values.add(valS[k]);
0247:
0248: }
0249:
0250: else {
0251:
0252: values.add(fragment);
0253:
0254: }
0255:
0256: }
0257:
0258: lfNew.setValues(values);
0259:
0260: document.add(lfNew);
0261:
0262: }
0263: // /Nouvel Ajout à tester
0264: else if (fieldName.equals("score")) {
0265: values.add(new Float(hits.score(i)));
0266: lfNew.setValues(values);
0267: document.add(lfNew);
0268: }
0269:
0270: }
0271:
0272: liusHits.add(document);
0273:
0274: }
0275:
0276: searcher.close();
0277:
0278: }
0279:
0280: catch (IOException a) {
0281:
0282: logger.error(a.getMessage());
0283:
0284: }
0285:
0286: return liusHits;
0287:
0288: }
0289:
0290: /**
0291: *
0292: * Permet d'effectuer une recherche et de retouner le résultat
0293: *
0294: * sous forme d'un objet de type JDOM Document.
0295: *
0296: * <br/><br/>
0297: *
0298: * Searches and returns the result as a JDOM object.
0299: *
0300: */
0301:
0302: public Document searchResultAsJdomDoc(String searchExp,
0303:
0304: String indexDir,
0305:
0306: String configFile) {
0307:
0308: Document liusXmlDoc = buildResultsAsJdomDocument(searchExp,
0309: indexDir,
0310:
0311: configFile);
0312:
0313: return liusXmlDoc;
0314:
0315: }
0316:
0317: /**
0318: *
0319: * Permet d'effectuer une recherche et de retouner le résultat
0320: *
0321: * sous forme d'un objet de type DOM Document.
0322: *
0323: * <br/><br/>
0324: *
0325: * Searches and returns the result as a DOM object.
0326: *
0327: */
0328:
0329: public org.w3c.dom.Document searchResultAsDomDoc(
0330: String rechercheExp,
0331:
0332: String indexDir,
0333:
0334: String configFile) {
0335:
0336: org.w3c.dom.Document domDoc = null;
0337:
0338: DOMOutputter dopt = new DOMOutputter();
0339:
0340: Document jdomDoc = searchResultAsJdomDoc(rechercheExp,
0341: indexDir, configFile);
0342:
0343: try {
0344:
0345: domDoc = dopt.output(jdomDoc);
0346:
0347: }
0348:
0349: catch (JDOMException e) {
0350:
0351: logger.error(e.getMessage());
0352:
0353: }
0354:
0355: return domDoc;
0356:
0357: }
0358:
0359: /**
0360: *
0361: * Permet de rechercher plusieurs indexes simultanément.
0362: *
0363: * <br/><br/>
0364: *
0365: * Searches many indexes at the same time.
0366: *
0367: */
0368:
0369: public List multiIndexSearch(String rechercheExp,
0370:
0371: List indexDirs,
0372:
0373: String configFile) {
0374:
0375: List liusHits = new ArrayList();
0376:
0377: Fragmenter fragmenter = null;
0378:
0379: String fragment = null;
0380:
0381: Vector values = null;
0382:
0383: QueryScorer scorer = null;
0384:
0385: SimpleHTMLFormatter formatter = null;
0386:
0387: Highlighter highlighter = null;
0388:
0389: try {
0390:
0391: LiusConfig xc = LiusConfigBuilder.getSingletonInstance().
0392:
0393: getLiusConfig(configFile);
0394:
0395: searcher = new MultiSearcher(buildSearchableTab(indexDirs));
0396:
0397: Query query = lq.getQueryFactory(xc.
0398:
0399: getElemSearch(),
0400:
0401: xc, rechercheExp);
0402:
0403: Hits hits = searcher.search(query);
0404:
0405: if (xc.getHighlighter() == true) {
0406:
0407: scorer = new QueryScorer(query.rewrite(new MultiReader(
0408:
0409: getSubReaders(indexDirs))));
0410:
0411: formatter =
0412:
0413: new SimpleHTMLFormatter("<span class=\"liusHit\">",
0414: "</span>");
0415:
0416: highlighter = new Highlighter(formatter, scorer);
0417:
0418: }
0419:
0420: Vector fieldsToDisplay = xc.getDisplayFields();
0421:
0422: for (int i = 0; i < hits.length(); i++) {
0423:
0424: List document = new ArrayList();
0425:
0426: for (int j = 0; j < fieldsToDisplay.size(); j++) {
0427:
0428: LiusField lf = (LiusField) fieldsToDisplay.get(j);
0429:
0430: if (xc.getHighlighter() == true) {
0431:
0432: if (lf.getFragmenter() != null) {
0433:
0434: fragmenter = new SimpleFragmenter(Integer
0435: .parseInt(lf.
0436:
0437: getFragmenter()));
0438:
0439: }
0440:
0441: else {
0442:
0443: fragmenter = new SimpleFragmenter(
0444: Integer.MAX_VALUE);
0445:
0446: }
0447:
0448: highlighter.setTextFragmenter(fragmenter);
0449:
0450: }
0451:
0452: LiusField lfNew = new LiusField();
0453:
0454: String fieldName = lf.getName();
0455:
0456: lfNew.setName(fieldName);
0457:
0458: lfNew.setLabel(lf.getLabel());
0459:
0460: String[] valS = hits.doc(i).getValues(fieldName);
0461:
0462: values = new Vector();
0463:
0464: if (valS != null) {
0465:
0466: for (int k = 0; k < valS.length; k++) {
0467:
0468: if (xc.getHighlighter() == true) {
0469:
0470: TokenStream stream = ((Analyzer) AnalyzerFactory
0471: .getAnalyzer(
0472:
0473: xc)).
0474:
0475: tokenStream(lf.getName(),
0476:
0477: new StringReader(valS[k]));
0478:
0479: if (lf.getFragmenter() != null)
0480:
0481: fragment = highlighter
0482: .getBestFragments(stream,
0483: valS[k], 5,
0484:
0485: "...");
0486:
0487: else {
0488:
0489: fragment = highlighter
0490: .getBestFragment(stream,
0491: valS[k]);
0492:
0493: }
0494:
0495: }
0496:
0497: if (fragment == null) {
0498:
0499: values.add(valS[k]);
0500:
0501: }
0502:
0503: else {
0504:
0505: values.add(fragment);
0506:
0507: }
0508:
0509: }
0510:
0511: lfNew.setValues(values);
0512:
0513: document.add(lfNew);
0514:
0515: }
0516: ///Nouvel Ajout à tester
0517: else if (fieldName.equals("score")) {
0518: values.add(new Float(hits.score(i)));
0519: lfNew.setValues(values);
0520: document.add(lfNew);
0521: }
0522: }
0523:
0524: liusHits.add(document);
0525:
0526: }
0527:
0528: searcher.close();
0529:
0530: }
0531:
0532: catch (IOException a) {
0533:
0534: logger.error(a.getMessage());
0535:
0536: }
0537:
0538: return liusHits;
0539:
0540: }
0541:
0542: public Document multiIndexSearchResultsAsJDom(String searchExp,
0543:
0544: List indexDirs,
0545:
0546: String configFile) {
0547:
0548: Document xmlDoc = buildResultsAsJdomDocument(searchExp,
0549: indexDirs,
0550:
0551: configFile);
0552:
0553: return xmlDoc;
0554:
0555: }
0556:
0557: public org.w3c.dom.Document multiIndexSearchResultsAsDom(
0558: String rechercheExp,
0559:
0560: List indexDirs,
0561:
0562: String configFile) {
0563:
0564: Document xmlDoc = buildResultsAsJdomDocument(rechercheExp,
0565: indexDirs,
0566:
0567: configFile);
0568:
0569: org.w3c.dom.Document domDoc = null;
0570:
0571: DOMOutputter dopt = new DOMOutputter();
0572:
0573: Document jdomDoc = multiIndexSearchResultsAsJDom(rechercheExp,
0574: indexDirs,
0575:
0576: configFile);
0577:
0578: try {
0579:
0580: domDoc = dopt.output(jdomDoc);
0581:
0582: }
0583:
0584: catch (JDOMException e) {
0585:
0586: logger.error(e.getMessage());
0587:
0588: }
0589:
0590: return domDoc;
0591:
0592: }
0593:
0594: /**
0595: *
0596: * Méthode se basant sur le fichier XML de configuration afin de
0597: *
0598: * construire l'analyseur et l'objet RangeQuery.
0599: *
0600: * Elle reçoit également le chemin de l'index et deux expressions de
0601: *
0602: * recherche entrées par l'utilisateur pour créer le RangeQuery.
0603: *
0604: * <br/><br/>
0605: *
0606: * Method based on the XML configuration file to construct the analyser
0607: *
0608: * and the RangeQuery object. It needs the path of the index and two search
0609: *
0610: * expressions given by user to create the RangeQuery.
0611: *
0612: */
0613:
0614: public List searchWithRangeQuery(String lowerSearchExp1,
0615:
0616: String lowerSearchExp2,
0617:
0618: String indexDir,
0619:
0620: String configFile) {
0621:
0622: Directory fsDir = null;
0623:
0624: List liusHits = new ArrayList();
0625:
0626: List document = new ArrayList();
0627:
0628: try {
0629:
0630: LiusConfig xc = LiusConfigBuilder.getSingletonInstance().
0631:
0632: getLiusConfig(configFile);
0633:
0634: if (LuceneActions.getSingletonInstance().indexExists(
0635: indexDir)) {
0636:
0637: fsDir = FSDirectory.getDirectory(indexDir, false);
0638:
0639: }
0640:
0641: searcher = new IndexSearcher(fsDir);
0642:
0643: Query query = lq.createRangeQuery(xc,
0644:
0645: lowerSearchExp1, lowerSearchExp2);
0646:
0647: Hits hits = searcher.search(query);
0648:
0649: List fieldsToDisplay = xc.getDisplayFields();
0650:
0651: for (int i = 0; i < hits.length(); i++) {
0652:
0653: for (int j = 0; j < fieldsToDisplay.size(); j++) {
0654:
0655: LiusField lf = (LiusField) fieldsToDisplay.get(j);
0656:
0657: String fieldName = lf.getName();
0658:
0659: String[] valS = hits.doc(i).getValues(fieldName);
0660:
0661: if (valS != null) {
0662:
0663: Vector v = tabToVector(valS);
0664:
0665: lf.setValues(v);
0666:
0667: document.add(lf);
0668:
0669: }
0670:
0671: }
0672: liusHits.add(document);
0673:
0674: }
0675:
0676: searcher.close();
0677:
0678: }
0679:
0680: catch (IOException a) {
0681:
0682: logger.error(a.getMessage());
0683:
0684: }
0685:
0686: return liusHits;
0687:
0688: }
0689:
0690: public Searchable[] buildSearchableTab(List indexDirs) {
0691:
0692: List index = putIndexs(indexDirs);
0693:
0694: searchables = new Searchable[index.size()];
0695:
0696: try {
0697:
0698: for (int i = 0; i < index.size(); i++) {
0699:
0700: Directory fsDir = FSDirectory.getDirectory(
0701: (String) index.get(i), false);
0702:
0703: searchables[i] = new IndexSearcher(fsDir);
0704:
0705: }
0706:
0707: }
0708:
0709: catch (IOException ex) {
0710:
0711: logger.error(ex.getMessage());
0712:
0713: }
0714:
0715: return searchables;
0716:
0717: }
0718:
0719: private List putIndexs(List indexDirs) {
0720:
0721: List indexExist = new ArrayList();
0722:
0723: for (int i = 0; i < indexDirs.size(); i++) {
0724:
0725: if (LuceneActions.getSingletonInstance().indexExists(
0726: (String)
0727:
0728: indexDirs.get(i))) {
0729:
0730: indexExist.add((String) indexDirs.get(i));
0731:
0732: }
0733:
0734: }
0735:
0736: return indexExist;
0737:
0738: }
0739:
0740: /**
0741: *
0742: * Méthode permettant de convertir un tableau en vecteur.
0743: *
0744: * <br/><br/>
0745: *
0746: * Method that converts an array to a vector.
0747: *
0748: */
0749:
0750: private Vector tabToVector(String[] tab) {
0751:
0752: Vector v = new Vector();
0753:
0754: for (int i = 0; i < tab.length; i++)
0755:
0756: v.add(tab[i]);
0757:
0758: return v;
0759:
0760: }
0761:
0762: public Document buildResultsAsJdomDocument(String searchExp,
0763:
0764: List indexDirs, String configFile) {
0765:
0766: Document liusXmlDoc = null;
0767:
0768: Searcher searcher = null;
0769:
0770: try {
0771:
0772: LiusConfig xc = LiusConfigBuilder.getSingletonInstance().
0773:
0774: getLiusConfig(configFile);
0775:
0776: searcher = new MultiSearcher(buildSearchableTab(indexDirs));
0777:
0778: IndexReader readers = new MultiReader(
0779: getSubReaders(indexDirs));
0780:
0781: liusXmlDoc = getXmlDocument(searcher, searchExp, xc,
0782: readers);
0783:
0784: }
0785:
0786: catch (IOException ex) {
0787:
0788: logger.error(ex.getMessage());
0789:
0790: }
0791:
0792: return liusXmlDoc;
0793:
0794: }
0795:
0796: public Document buildResultsAsJdomDocument(String searchExp,
0797:
0798: String indexDir, String configFile) {
0799:
0800: LiusConfig xc = null;
0801:
0802: Directory fsDir = null;
0803:
0804: Document liusXmlDoc = null;
0805:
0806: try {
0807:
0808: xc = LiusConfigBuilder.getSingletonInstance().
0809:
0810: getLiusConfig(configFile);
0811:
0812: if (LuceneActions.getSingletonInstance().indexExists(
0813: indexDir)) {
0814:
0815: fsDir = FSDirectory.getDirectory(indexDir, false);
0816:
0817: }
0818:
0819: Searcher searcher = new IndexSearcher(fsDir);
0820:
0821: liusXmlDoc = getXmlDocument(searcher, searchExp, xc,
0822:
0823: IndexReader.open(fsDir));
0824:
0825: }
0826:
0827: catch (IOException e) {
0828:
0829: logger.error(e.getMessage());
0830:
0831: }
0832:
0833: return liusXmlDoc;
0834:
0835: }
0836:
0837: private Document getXmlDocument(Searcher searcher,
0838: String searchExp,
0839:
0840: LiusConfig xc, IndexReader reader) {
0841:
0842: Document liusXmlDoc = null;
0843:
0844: Fragmenter fragmenter = null;
0845:
0846: String fragment = null;
0847:
0848: QueryScorer scorer = null;
0849:
0850: SimpleHTMLFormatter formatter = null;
0851:
0852: Highlighter highlighter = null;
0853:
0854: Query query = lq.getQueryFactory(xc.
0855:
0856: getElemSearch(),
0857:
0858: xc, searchExp);
0859:
0860: Hits hits = null;
0861:
0862: try {
0863:
0864: hits = searcher.search(query);
0865:
0866: if (xc.getHighlighter()) {
0867:
0868: scorer = new QueryScorer(query.rewrite(reader));
0869:
0870: formatter =
0871:
0872: new SimpleHTMLFormatter("<liusHit>", "</liusHit>");
0873:
0874: highlighter = new Highlighter(formatter, scorer);
0875:
0876: }
0877:
0878: Element results = new Element("results")
0879: .setAttribute(new Attribute(
0880:
0881: "size", "" + hits.length()));
0882:
0883: liusXmlDoc = new Document(results);
0884:
0885: for (int i = 0; i < hits.length(); i++) {
0886:
0887: Element resDocument = new Element("Document");
0888:
0889: resDocument.setAttribute(new Attribute("score", ""
0890: + hits.score(i)));
0891:
0892: Vector fieldsToDisplay = xc.getDisplayFields();
0893:
0894: for (int j = 0; j < fieldsToDisplay.size(); j++) {
0895:
0896: LiusField lf = (LiusField) fieldsToDisplay.get(j);
0897:
0898: if (xc.getHighlighter()) {
0899:
0900: if (lf.getFragmenter() != null) {
0901:
0902: fragmenter = new SimpleFragmenter(Integer
0903: .parseInt(lf.
0904:
0905: getFragmenter()));
0906:
0907: }
0908:
0909: else {
0910:
0911: fragmenter = new SimpleFragmenter(
0912: Integer.MAX_VALUE);
0913:
0914: }
0915:
0916: highlighter.setTextFragmenter(fragmenter);
0917:
0918: }
0919:
0920: String[] valS = hits.doc(i).getValues(lf.getName());
0921:
0922: if (valS != null) {
0923:
0924: StringBuffer values = new StringBuffer();
0925:
0926: values.append("<Field name=\"" + lf.getName()
0927: + "\" label=\"" +
0928:
0929: lf.getLabel() + "\">");
0930:
0931: for (int k = 0; k < valS.length; k++) {
0932:
0933: if (xc.getHighlighter()) {
0934:
0935: TokenStream stream = ((Analyzer) AnalyzerFactory
0936: .getAnalyzer(
0937:
0938: xc)).
0939:
0940: tokenStream(lf.getName(),
0941:
0942: new StringReader(valS[k]));
0943:
0944: if (lf.getFragmenter() != null)
0945:
0946: fragment = highlighter
0947: .getBestFragments(stream,
0948: valS[k], 5,
0949:
0950: "...");
0951:
0952: else {
0953:
0954: fragment = highlighter
0955: .getBestFragment(stream,
0956: valS[k]);
0957:
0958: }
0959:
0960: }
0961:
0962: if (fragment == null) {
0963:
0964: values.append("<value>" + valS[k]
0965: + "</value>");
0966:
0967: }
0968:
0969: else {
0970:
0971: String fragmentDoc = "<value>"
0972: + fragment + "</value>";
0973:
0974: values.append(fragmentDoc);
0975:
0976: }
0977:
0978: }
0979:
0980: values.append("</Field>");
0981:
0982: System.out.println(values.toString());
0983:
0984: Element field = transformStringToElement(values);
0985:
0986: resDocument.addContent(field);
0987:
0988: }
0989:
0990: }
0991:
0992: results.addContent(resDocument);
0993:
0994: }
0995:
0996: }
0997:
0998: catch (IOException ex) {
0999:
1000: logger.error(ex.getMessage());
1001:
1002: }
1003:
1004: return liusXmlDoc;
1005:
1006: }
1007:
1008: private static Element transformStringToElement(StringBuffer buffer) {
1009:
1010: org.jdom.Document xmlDoc = new org.jdom.Document();
1011:
1012: try {
1013:
1014: SAXBuilder builder = new SAXBuilder();
1015:
1016: builder.setValidation(false);
1017:
1018: xmlDoc = builder.build(new StringReader(buffer.toString()));
1019:
1020: }
1021:
1022: catch (JDOMException e) {
1023:
1024: logger.error(e.getMessage());
1025:
1026: }
1027:
1028: catch (IOException e) {
1029:
1030: logger.error(e.getMessage());
1031:
1032: }
1033:
1034: return xmlDoc.getRootElement().detach();
1035:
1036: }
1037:
1038: private IndexReader[] getSubReaders(List indexes) {
1039:
1040: List existIndexes = putIndexs(indexes);
1041:
1042: IndexReader[] tabReaders = new IndexReader[existIndexes.size()];
1043:
1044: for (int i = 0; i < existIndexes.size(); i++) {
1045:
1046: try {
1047:
1048: Directory fsDir = FSDirectory.getDirectory(
1049: (String) existIndexes.get(i), false);
1050:
1051: tabReaders[i] = IndexReader.open(fsDir);
1052:
1053: }
1054:
1055: catch (IOException ex) {
1056:
1057: logger.error(ex.getMessage());
1058:
1059: }
1060:
1061: }
1062:
1063: return tabReaders;
1064:
1065: }
1066:
1067: }
|