王秋城博客

//此处的10表示s_device0,s_device1,…s_device10,
//s_device表示数据库的表名
int detotal=procedureService.savetotal(10, “s_device”);
下面是dao的调用
@Repository
public class ProcedureDaoImpl<T> extends BaseDao<T> implements IProcedureDao{
     @Override
     public int savetotal(int count, String str) {
          String procedure_name=“query_deviceCount”;   //存储过程的名字
          ProcedureCall query =this.getSession().createStoredProcedureCall(procedure_name);  
          //存入的字段 ParameterMode.IN表示存进来的参数值，ParameterMode.OUT最后执行完这个参数获得数值。
          query.registerParameter(“p_num”, Integer.class, ParameterMode.IN).bindValue(count);
          query.registerParameter(“p_strs”,String.class, ParameterMode.IN).bindValue(str);
          query.registerParameter(“p_count”, Integer.class, ParameterMode.OUT);
          System.out.println(query.getOutputs());   //获取执行存储过程最后输出的参数
          return (int) query.getOutputs().getOutputParameterValue(“p_count”);   //数据库输出参数的名字
    }
}

String keywords = “钟福成”;
List<Article> articleList = new ArrayList<Article>();
QueryParser queryParser = new QueryParser(LuceneUtil.getVersion(),”content”,LuceneUtil.getAnalyzer());
Query query = queryParser.parse(keywords);
IndexSearcher indexSearcher = new IndexSearcher(LuceneUtil.getDirectory());
TopDocs topDocs = indexSearcher.search(query,1000000);
//设置关键字高亮
Formatter formatter = new SimpleHTMLFormatter(“<font color=’red’>”,”</font>”);
Scorer scorer = new QueryScorer(query);
Highlighter highlighter = new Highlighter(formatter,scorer);


//设置摘要
Fragmenter fragmenter = new SimpleFragmenter(4);
highlighter.setTextFragmenter(fragmenter);

for(int i=0;i<topDocs.scoreDocs.length;i++){
    ScoreDoc scoreDoc = topDocs.scoreDocs[i];
    int no = scoreDoc.doc;
    Document document = indexSearcher.doc(no);
    //设置内容高亮
    String highlighterContent = highlighter.getBestFragment(LuceneUtil.getAnalyzer(),”content”,document.get(“content”));
    document.getField(“content”).setValue(highlighterContent);
    Article article = (Article) LuceneUtil.document2javabean(document,Article.class);
    articleList.add(article);
}
for(Article article : articleList){
    System.out.println(article);
}

Article article = new Article(1,”培训”,”传智是一家Java培训机构”);
Document document = LuceneUtil.javabean2document(article);
Directory fsDirectory = FSDirectory.open(new File(“E:/indexDBDBDBDBDBDBDBDB”));
    //硬盘索引库
Directory ramDirectory = new RAMDirectory(fsDirectory);
IndexWriter fsIndexWriter = new IndexWriter(fsDirectory,LuceneUtil.getAnalyzer(),true,LuceneUtil.getMaxFieldLength());
IndexWriter ramIndexWriter = new IndexWriter(ramDirectory,LuceneUtil.getAnalyzer(),LuceneUtil.getMaxFieldLength());
ramIndexWriter.addDocument(document);
ramIndexWriter.close();
fsIndexWriter.addIndexesNoOptimize(ramDirectory);
fsIndexWriter.close();

import org.apache.commons.beanutils.BeanUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* Created by ozc on 2017/7/12.
*/
/**
* 使用单例事例模式
* */
public class LuceneUtils {
    private static Directory directory;
    private static Analyzer analyzer;
    private static IndexWriter.MaxFieldLength maxFieldLength;
    private LuceneUtils() {}
    static{
        try {
            directory = FSDirectory.open(new File(“E:/createIndexDB”));
            analyzer = new StandardAnalyzer(Version.LUCENE_30);
            maxFieldLength = IndexWriter.MaxFieldLength.LIMITED;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Directory getDirectory() {
        return directory;
    }
    public static Analyzer getAnalyzer() {
        return analyzer;
    }
    public static IndexWriter.MaxFieldLength getMaxFieldLength() {
        return maxFieldLength;
    }
    /**
     * @param object 传入的JavaBean类型
     * @return 返回Document对象
     */
    public static Document javaBean2Document(Object object) {
        try {
            Document document = new Document();
            //得到JavaBean的字节码文件对象
            Class<?> aClass = object.getClass();
            //通过字节码文件对象得到对应的属性【全部的属性，不能仅仅调用getFields()】
            Field[] fields = aClass.getDeclaredFields();
            //得到每个属性的名字
            for (Field field : fields) {
                String name = field.getName();
                //得到属性的值【也就是调用getter方法获取对应的值】
                String method = “get” + name.substring(0, 1).toUpperCase() + name.substring(1);
                //得到对应的值【就是得到具体的方法，然后调用就行了。因为是get方法，没有参数】
                Method aClassMethod = aClass.getDeclaredMethod(method, null);
                String value = aClassMethod.invoke(object).toString();
                System.out.println(value);
                //把数据封装到Document对象中。
                document.add(new org.apache.lucene.document.Field(name, value, org.apache.lucene.document.Field.Store.YES, org.apache.lucene.document.Field.Index.ANALYZED));
            }
            return document;
        }  catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * @param aClass   要解析的对象类型，要用户传入进来
     * @param document 将Document对象传入进来
     * @return 返回一个JavaBean
     */
    public static Object Document2JavaBean(Document document, Class aClass) {
        try {
            //创建该JavaBean对象
            Object obj = aClass.newInstance();
            //得到该JavaBean所有的成员变量
            Field[] fields = aClass.getDeclaredFields();
            for (Field field : fields) {
                //设置允许暴力访问
                field.setAccessible(true);
                String name = field.getName();
                String value = document.get(name);
                //使用BeanUtils把数据封装到Bean中
                BeanUtils.setProperty(obj, name, value);
            }
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    @Test
    public void test() {
        User user = new User();
        LuceneUtils.javaBean2Document(user);
    }
}

@Test
public void createIndexDB() throws Exception {
    //把数据填充到JavaBean对象中
    User user = new User(“2”, “钟福成2”, “未来的程序员2”);
    Document document = LuceneUtils.javaBean2Document(user);
    /**
     * IndexWriter将我们的document对象写到硬盘中
     *
     * 参数一：Directory d,写到硬盘中的目录路径是什么
     * 参数二：Analyzer a, 以何种算法来对document中的原始记录表数据进行拆分成词汇表
     * 参数三：MaxFieldLength mfl 最多将文本拆分出多少个词汇
     *
     * */
    IndexWriter indexWriter = new IndexWriter(LuceneUtils.getDirectory(), LuceneUtils.getAnalyzer(), LuceneUtils.getMaxFieldLength());
    //将Document对象通过IndexWriter对象写入索引库中
    indexWriter.addDocument(document);
    //关闭IndexWriter对象
    indexWriter.close();
}
@Test
public void findIndexDB() throws Exception {
    //创建IndexSearcher对象
    IndexSearcher indexSearcher = new IndexSearcher(LuceneUtils.getDirectory());
    //创建QueryParser对象
    QueryParser queryParser = new QueryParser(Version.LUCENE_30, “userName”, LuceneUtils.getAnalyzer());
    //给出要查询的关键字
    String keyWords = “钟”;
    //创建Query对象来封装关键字
    Query query = queryParser.parse(keyWords);
    //用IndexSearcher对象去索引库中查询符合条件的前100条记录，不足100条记录的以实际为准
    TopDocs topDocs = indexSearcher.search(query, 100);
    //获取符合条件的编号
    for (int i = 0; i < topDocs.scoreDocs.length; i++) {
        ScoreDoc scoreDoc = topDocs.scoreDocs[i];
        int no = scoreDoc.doc;
        //用indexSearcher对象去索引库中查询编号对应的Document对象
        Document document = indexSearcher.doc(no);
        //将Document对象中的所有属性取出，再封装回JavaBean对象中去
        User user = (User) LuceneUtils.Document2JavaBean(document, User.class);
        System.out.println(user);
    }
}

@Test
public void findIndexDB() throws Exception {
/**
* 参数一： IndexSearcher(Directory path)查询以xxx目录的索引库
*
* */
Directory directory = FSDirectory.open(new File(“E:/createIndexDB”));
//创建IndexSearcher对象
IndexSearcher indexSearcher = new IndexSearcher(directory);
//创建QueryParser对象
/**
* 参数一： Version matchVersion 版本号【和上面是一样的】
* 参数二：String f,【要查询的字段】
* 参数三：Analyzer a【使用的拆词算法】
* */
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
QueryParser queryParser = new QueryParser(Version.LUCENE_30, “userName”, analyzer);
//给出要查询的关键字
String keyWords = “钟”;
//创建Query对象来封装关键字
Query query = queryParser.parse(keyWords);
//用IndexSearcher对象去索引库中查询符合条件的前100条记录，不足100条记录的以实际为准
TopDocs topDocs = indexSearcher.search(query, 100);
//获取符合条件的编号
for (int i = 0; i < topDocs.scoreDocs.length; i++) {
ScoreDoc scoreDoc = topDocs.scoreDocs[i];
int no = scoreDoc.doc;
//用indexSearcher对象去索引库中查询编号对应的Document对象
Document document = indexSearcher.doc(no);
//将Document对象中的所有属性取出，再封装回JavaBean对象中去
String id = document.get(“id”);
String userName = document.get(“userName”);
String sal = document.get(“sal”);
User user = new User(id, userName, sal);
System.out.println(user);
}

@Test
public void createIndexDB() throws Exception {
    //把数据填充到JavaBean对象中
    User user = new User(“1”, “钟福成”, “未来的程序员”);
    //创建Document对象【导入的是Lucene包下的Document对象】
    Document document = new Document();
    //将JavaBean对象所有的属性值，均放到Document对象中去，属性名可以和JavaBean相同或不同
    /**
     * 向Document对象加入一个字段
     * 参数一：字段的关键字
     * 参数二：字符的值
     * 参数三：是否要存储到原始记录表中
     *      YES表示是
     *      NO表示否
     * 参数四：是否需要将存储的数据拆分到词汇表中
     *      ANALYZED表示拆分
     *      NOT_ANALYZED表示不拆分
     *
     * */
    document.add(new Field(“id”, user.getId(), Field.Store.YES, Field.Index.ANALYZED));
    document.add(new Field(“userName”, user.getUserName(), Field.Store.YES, Field.Index.ANALYZED));
    document.add(new Field(“sal”, user.getSal(), Field.Store.YES, Field.Index.ANALYZED));
    //创建IndexWriter对象
    //目录指定为E:/createIndexDB
    Directory directory = FSDirectory.open(new File(“E:/createIndexDB”));
    //使用标准的分词算法对原始记录表进行拆分
    Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30);
    //LIMITED默认是1W个
    IndexWriter.MaxFieldLength maxFieldLength = IndexWriter.MaxFieldLength.LIMITED;
    /**
     * IndexWriter将我们的document对象写到硬盘中
     *
     * 参数一：Directory d,写到硬盘中的目录路径是什么
     * 参数二：Analyzer a, 以何种算法来对document中的原始记录表数据进行拆分成词汇表
     * 参数三：MaxFieldLength mfl 最多将文本拆分出多少个词汇
     *
     * */
    IndexWriter indexWriter = new IndexWriter(directory, analyzer, maxFieldLength);
    //将Document对象通过IndexWriter对象写入索引库中
    indexWriter.addDocument(document);
    //关闭IndexWriter对象
    indexWriter.close();
}