Lucene7.1案例

使用Lucene7.1、jdk1.8

1、创建maven项目、导入依赖


    
      org.apache.lucene
      lucene-core
      7.1.0
    

    
      org.apache.lucene
      lucene-analyzers-smartcn
      7.1.0
    

    
      org.apache.lucene
      lucene-queryparser
      7.1.0
    

    
      org.apache.lucene
      lucene-highlighter
      7.1.0
    
    
      junit
      junit
      4.12

2、创建包、创建实体类

package com.mrzhong.pojo;

import java.io.Serializable;

public class Goods implements Serializable {

    private static final long serialVersionUID = 5251314995707817799L;

    private Integer goodsId;
    private String goodsName;
    private Double goodsPrice;
    private String goodsRemark;

    public Goods() {
        super();
    }
    public Goods(Integer goodsId, String goodsName, Double goodsPrice,
                 String goodsRemark) {
        super();
        this.goodsId = goodsId;//商品ID
        this.goodsName = goodsName;//商品名称
        this.goodsPrice = goodsPrice;//商品价格
        this.goodsRemark = goodsRemark;//商品备注、描述
    }
    @Override
    public String toString() {
        return "Goods [goodsId=" + goodsId + ", goodsName=" + goodsName
                + ", goodsPrice=" + goodsPrice + ", goodsRemark=" + goodsRemark
                + "]";
    }
    public Integer getGoodsId() {
        return goodsId;
    }
    public void setGoodsId(Integer goodsId) {
        this.goodsId = goodsId;
    }
    public String getGoodsName() {
        return goodsName;
    }
    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName;
    }
    public Double getGoodsPrice() {
        return goodsPrice;
    }
    public void setGoodsPrice(Double goodsPrice) {
        this.goodsPrice = goodsPrice;
    }
    public String getGoodsRemark() {
        return goodsRemark;
    }
    public void setGoodsRemark(String goodsRemark) {
        this.goodsRemark = goodsRemark;
    }
}

3、编写保存商品、查询商品的持久层类

package com.mrzhong.MyLucene;

import com.mrzhong.pojo.Goods;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

public class FirstLuceneDaoImpl {

    /**
     * 保存一个商品
     * @throws IOException
     */
    public void saveGoods(Goods goods) throws IOException {

        //保存路径
        final Path path = Paths.get("./src/main/dir");
        //构建索引库
        Directory directory = FSDirectory.open(path);
        //设置分词器
        Analyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer);
        //设置打开索引库读写的方式：CREATE->覆盖原来索引，APPEND->追加到原来的索引。
        indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE);

        //创建增删改索引库的操作对象，添加文档并提交
        IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);
        //创建文档对象
        Document document = new Document();
        document.add(new TextField("goodsId", goods.getGoodsId().toString(), Field.Store.YES));
        document.add(new TextField("goodsName", goods.getGoodsName().toString(), Field.Store.YES));
        document.add(new TextField("goodsRemark", goods.getGoodsRemark().toString(), Field.Store.YES));
        document.add(new TextField("goodsPrice", goods.getGoodsPrice().toString(), Field.Store.YES));

        indexWriter.addDocument(document);
        indexWriter.close();

    }

    public List searchGoods(String goodsName) throws IOException, org.apache.lucene.queryparser.classic.ParseException {

        List reGoods = new ArrayList<>();

        //String queryString = "全文检索";
        String queryString  = goodsName;

        //多条件
        //Query q = MultiFieldQueryParser.parse(new String[]{},new String[]{},new StandardAnalyzer());

        //设置路径
        final Path path = Paths.get("./src/main/dir");
        //打开索引库
        Directory directory = FSDirectory.open(path);
        Analyzer analyzer = new StandardAnalyzer();

        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        //单条件查询--创建查询解析器
        QueryParser queryParser = new QueryParser("goodsName",analyzer);
        Query query = queryParser.parse(queryString);

        //执行查询--设置返回最多条数
        TopDocs topDocs = indexSearcher.search(query,10);

        long conut = topDocs.totalHits;
        System.out.println("检索总条数："+conut);

        //根据文档编号遍历真正的文档
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {
            Goods goods = new Goods();
            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println("相关度："+scoreDoc.score+"-----time:"+document.get("time"));

            goods.setGoodsId(Integer.parseInt(document.get("goodsId")));
            goods.setGoodsName(document.get("goodsName"));
            goods.setGoodsPrice(Double.parseDouble(document.get("goodsPrice")));
            goods.setGoodsRemark(document.get("goodsRemark"));

            reGoods.add(goods);
        }
        return reGoods;
    }
}

4、测试类

package com.mrzhong.MyLucene;

import com.mrzhong.pojo.Goods;
import org.apache.lucene.queryparser.classic.ParseException;
import org.junit.Test;

import java.io.IOException;
import java.util.List;

public class FirstLunceneDaoImplTest {

    public static void main(String[] args) {}

    @Test
    public void addTest(){

        Goods goods=new Goods(2,"OPPO高端手机001",11.1,"OPPO手机就是666，全国第一品牌");
        FirstLuceneDaoImpl firstLuceneDaoImpl = new FirstLuceneDaoImpl();
        try {
            firstLuceneDaoImpl.saveGoods(goods);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("-------保存成功！-------");

    }

    @Test
    public void searchTest(){
        String goodsName = "手机";
        FirstLuceneDaoImpl firstLuceneDaoImpl = new FirstLuceneDaoImpl();
        try {
            List re = firstLuceneDaoImpl.searchGoods(goodsName);

            re.forEach(v->System.out.println(v.toString()));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

工具类编写

配置信息类

package com.mrzhong.LuceneUtil;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import java.nio.file.Paths;

/**
 * 配置信息类
 */
public class Configuration {

    private Configuration(){}

    public  static final Analyzer ANALYZER=new StandardAnalyzer();
    private static Directory DIRECTORY;
    private static String PATH="./src/main/dir";

    static{
        try{
            DIRECTORY= FSDirectory.open(Paths.get(PATH));
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    public static Directory getDIRECTORY() {
        return DIRECTORY;
    }
}

编写javaBean和document互转的工具类

package com.mrzhong.LuceneUtil;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import static com.sun.org.glassfish.gmbal.ManagedObjectManagerFactory.getMethod;

public class BeanUtils {

    /**
     * 普通javaBean转成Lucene文档类
     * @param obj
     * @return
     * @throws Exception
     */
    public static Document beanToDocument(Object obj) throws Exception {

        //创建文档类
        Document document = new Document();

        //获取javaBean的字节码
        Class clazz  = obj.getClass();

        //获取Field对象数组
        Field reflectFields[] = clazz.getDeclaredFields();

        //遍历
        for (Field field: reflectFields) {

            //设置特权访问
            field.setAccessible(true);
            //获取字段名
            String fieldName = field.getName();

            //根据字段、合成get方法--javaBean编写规范：字段首字母小写xxXxx,get、set方法驼峰式getXxxXx()
            String init = fieldName.substring(0, 1).toUpperCase();
            String methodName = "get" + init + fieldName.substring(1);

            //根据字段的get方法名，获取反射的方法类
            Method reflectMethod = getMethod(clazz, methodName);

            //判断、获取方法返回的结果
            if (reflectMethod!=null){
                //执行、返回结果
                Object returnValue = reflectMethod.invoke(obj,null);
                //判断返回结果是否为空，避免为空
                if(returnValue == null){
                    continue;
                }
                //将方法的返回结果添加到文档对象中
                document.add(new TextField(fieldName,returnValue.toString(), org.apache.lucene.document.Field.Store.YES));
            }else {
                continue;
            }
        }
        return document;
    }

    public static Object documentToBean(Document document,Class clazz) throws Exception {

        Object obj = clazz.newInstance();

        //根据javaBean字节码获取字段数组
        Field[] reflectField = clazz.getDeclaredFields();

        //遍历
        for(Field field: reflectField){

            //设置特权访问
            field.setAccessible(true);

            //获取字段的名字
            String fieldName = field.getName();

            String documentFieldValue = document.get(fieldName);

            if(documentFieldValue == null ){
                continue;
            }

            //给属性赋值
            org.apache.commons.beanutils.BeanUtils.setProperty(obj, fieldName,
                    documentFieldValue);
        }
        return obj;
    }
}

编写IndexWriter封装工具类

package com.mrzhong.LuceneUtil;

import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;

import java.io.IOException;

public class IndexWriterUtils {
    private IndexWriterUtils(){}

    private static IndexWriter indexWriter;

    static{
        try {
            IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Configuration.ANALYZER);
            indexWriterConfig.setOpenMode(IndexWriterConfig.OpenMode.APPEND);
            indexWriter=new IndexWriter(Configuration.getDIRECTORY(), indexWriterConfig);
            //注册事件，应用关闭时释放资源;addShutdownHook可以添加JVM停止时要处理事件。
            Runtime.getRuntime().addShutdownHook(new Thread(){
                public void run(){
                    try {
                        indexWriter.close();
                        System.out.println("indexWriter is close");
                    } catch (CorruptIndexException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static IndexWriter getIndexWriter(){
        return indexWriter;
    }

}

测试工具类

package com.mrzhong.LuceneUtil;

import com.mrzhong.pojo.Goods;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.junit.Test;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

/**
 * 工具测试类
 */
public class LunceneUtilTest {

    @Test
    public void testBeanToDocument() throws Exception {

        Goods goods=new Goods(5,"华为荣耀6Plus",11.1,"华为手机就是666，全国第二品牌");

        //创建增删改索引库的操作对象，添加文档并提交
        IndexWriter indexWriter = IndexWriterUtils.getIndexWriter();
        //创建文档对象
        Document document = BeanUtils.beanToDocument(goods);

        //提交文档对象
        indexWriter.addDocument(document);
        indexWriter.close();

        System.out.println("保存成功---------");

    }

    @Test
    public void testDocumentToBean() throws Exception {

        List reGoods = new ArrayList<>();

        //String queryString = "全文检索";
        String queryString  = "华为荣耀6Plus";

        //多条件
        //Query q = MultiFieldQueryParser.parse(new String[]{},new String[]{},new StandardAnalyzer());

        //获取索引库
        Directory directory = Configuration.getDIRECTORY();

        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        //单条件查询--创建查询解析器
        QueryParser queryParser = new QueryParser("goodsName",Configuration.ANALYZER);
        Query query = queryParser.parse(queryString);

        //执行查询--设置返回最多条数
        TopDocs topDocs = indexSearcher.search(query,10);

        long conut = topDocs.totalHits;
        System.out.println("检索总条数："+conut);

        //根据文档编号遍历真正的文档
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {

            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println("相关度："+scoreDoc.score);

            //将文档对象转成javaBean
            Goods goods = (Goods) BeanUtils.documentToBean(document,Goods.class);

            reGoods.add(goods);
        }

        reGoods.forEach(v->System.out.println(v.toString()));
    }
}

简单CRUD

Dao层接口

package com.mrzhong.LuceneCrud;

import java.io.IOException;
import java.util.List;

/**
 * LuceneDao层接口
 */
public interface LuceneDao {

    //查询接口--多条件查询：参数1:-查询关键字，参数2：参与查询的字段
    public List search(String[] queryies, String[] fields,Class clazz) throws IOException, Exception;

    //保存接口
    public void save(Object object) throws Exception;

    //修改接口:参数1-检索的字段名，参数2：更新的对象
    public Boolean update(String fieldName,Object object);

    //删除接口
    public Boolean delete(String fieldName, String fieldValue);

}

Dao层接口实现类

package com.mrzhong.LuceneCrud;

import com.mrzhong.LuceneUtil.BeanUtils;
import com.mrzhong.LuceneUtil.Configuration;
import com.mrzhong.LuceneUtil.IndexWriterUtils;
import com.mrzhong.pojo.Goods;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import static com.sun.org.glassfish.gmbal.ManagedObjectManagerFactory.getMethod;

public class LuceneDaoImpl implements LuceneDao{

    private Directory directory = Configuration.getDIRECTORY();

    @Override
    public List search(String[] queryies, String[] fields,Class clazz) throws Exception {

        List reObject = new ArrayList<>();

        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        //多条件
        Query query = MultiFieldQueryParser.parse(queryies,fields,Configuration.ANALYZER);
        //单条件查询--创建查询解析器
        /*QueryParser queryParser = new QueryParser("goodsName",Configuration.ANALYZER);
        Query query = queryParser.parse(qureyString);*/

        //执行查询--设置返回最多条数
        TopDocs topDocs = indexSearcher.search(query,10);

        long conut = topDocs.totalHits;
        System.out.println("检索总条数："+conut);

        //根据文档编号遍历真正的文档
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {

            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println("相关度："+scoreDoc.score);

            //将文档对象转成javaBean
            Object object = BeanUtils.documentToBean(document,clazz);

            reObject.add(object);
        }

        return reObject;
    }

    @Override
    public void save(Object object) throws Exception {
        try {
            //创建增删改索引库的操作对象，添加文档并提交
            IndexWriter indexWriter = IndexWriterUtils.getIndexWriter();
            //创建文档对象
            Document document = BeanUtils.beanToDocument(object);

            //提交文档对象
            indexWriter.addDocument(document);
            indexWriter.commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public Boolean update(String fieldName, Object object) {
        try {
            IndexWriter indexWriter = IndexWriterUtils.getIndexWriter();
            Document doc = BeanUtils.beanToDocument(object);
            /*
             *根据字段的值进行修改数据内容；原则，先删除再添加
             *如果字段值不存在，将新增一条记录（文档）
             *如果字段值唯一，那就相当 于根据主键修改数据；
             *如果字段值对应有多条数据记录（文档），则其它记录（文档）将被逻辑删除后，再添加一记录（文档）
             */
            //根据检索的字段，获取更新对象下该字段的值
            Class clazz = object.getClass();
            String init = fieldName.substring(0, 1).toUpperCase();
            String methodName = "get" + init + fieldName.substring(1);
            Method reflectMethod = getMethod(clazz, methodName);
            Object fieldValue = reflectMethod.invoke(object,null);
            indexWriter.updateDocument(new Term(fieldName,fieldValue.toString()), doc);

            indexWriter.commit();

            return true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }

    }

    @Override
    public Boolean delete(String fieldName, String fieldValue) {

        try {
            IndexWriter indexWriter = IndexWriterUtils.getIndexWriter();
            // 参数一：指定处理的字段，参数二：指定关键字(词），如果对应多条记录，多条记录也被删除
            indexWriter.deleteDocuments(new Term(fieldName, fieldValue));
            // 提交事务
            indexWriter.commit();

            return true;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

            return false;
        }
    }
} 
  
接口实现类测试
 
  
package com.mrzhong.LuceneCrud;

import com.mrzhong.pojo.Goods;
import com.mrzhong.pojo.Person;
import org.junit.Test;

import java.util.List;

/**
 * 测试类
 */
public class LuceneDaoImplTest {

    LuceneDao luceneDao = new LuceneDaoImpl();

    //测试保存
    @Test
    public void testSave() throws Exception {
        Goods goods=new Goods(2,"小米电视2s",11.1,"全面屏，带你体验不一样的视觉盛宴.2s");
        luceneDao.save(goods);
    }

    //测试查询
    @Test
    public void testSearch() throws Exception {
       List reGoods = luceneDao.search(new String[]{"小米"},new String[]{"goodsName"},Goods.class);
       reGoods.forEach(v->System.out.println(v.toString()));
    }

    //测试更新
    @Test
    public void testUpdate(){
        Goods goods=new Goods(1,"小米电视1s",11.1,"全面屏，带你体验不一样的视觉盛宴。价格优惠");
        luceneDao.update("goodsId",goods);
    }

    //测试删除
    @Test
    public void testDelete(){
        luceneDao.delete("goodsId","1");
    }
}
 
  
分页查询
 
  
Dao层添加接口
 
  
//分页查询接口--多条件查询
    public List searchByPage(String[] queryies, String[] fields,int pageIndex,int pageSize,Class clazz) throws IOException, Exception;
 
  
接口实现类
 
  
@Override
    public List searchByPage(String[] queryies, String[] fields, int pageIndex, int pageSize, Class clazz) throws IOException, Exception {

        List reObject = new ArrayList<>();

        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        if(pageIndex<1){
            pageIndex=1;
        }
        if(pageSize<1){
            pageSize=1;
        }

        //查询页的开始记录数的序号
        int startRecord=(pageIndex-1)*pageSize;
        //查询页的结束记录数序号
        int endRecord=pageIndex*pageSize;

        //多条件
        Query query = MultiFieldQueryParser.parse(queryies,fields,Configuration.ANALYZER);
        //单条件查询--创建查询解析器
        /*QueryParser queryParser = new QueryParser("goodsName",Configuration.ANALYZER);
        Query query = queryParser.parse(qureyString);*/

        //执行查询--设置返回最多条数
        TopDocs topDocs = indexSearcher.search(query,endRecord);

        long conut = topDocs.totalHits;
        System.out.println("检索总条数："+conut);

        if(topDocs.totalHits<=startRecord){
            System.out.println("没有记录了！");
            return null;
        }

        if(endRecord>topDocs.totalHits){
            endRecord= (int) topDocs.totalHits;
        }

        //根据文档编号遍历真正的文档
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;

        for (int i=startRecord;i 
  
测试类
 
  
//测试分页查询
    @Test
    public void testSearchByPage() throws Exception {
        List reGoods = luceneDao.searchByPage(new String[]{"小米"},new String[]{"goodsName"},2,2,Goods.class);
        reGoods.forEach(v->System.out.println(v.toString()));
    }
 
  
结果高亮显示
 
  
高亮工具类
 
  
package com.mrzhong.LuceneUtil;

import org.apache.lucene.search.Query;
import org.apache.lucene.search.highlight.*;

import java.util.List;

public class HighLightUtil {

    public static String doHighLight(Query query, String fieldName, String fieldValue, int size){
        String result="";
        try {
            //设置高亮的格式
            Formatter formatter=new SimpleHTMLFormatter("","");
            //指定高亮的查询条件
            Scorer scorer=new QueryScorer(query);

            Highlighter highlighter=new Highlighter(formatter, scorer);
            //指定高亮后的长度，需要SimpleFragmenter类型参数，这里指定长度为参数size（结尾为标点符号或不够长的词一般不显示出来,所以一般会少几个字）
            highlighter.setTextFragmenter(new SimpleFragmenter(size));
            //设置对哪个字段进行高亮操作，返回高亮后的结果
            result=highlighter.getBestFragment(Configuration.ANALYZER, fieldName, fieldValue);
            //把高亮后的值重新赋给字段
            if(result==null){
                if(fieldValue!=null&&fieldValue.length()>=size){
                    result=fieldValue.substring(0, size);
                }else{
                    result=fieldValue;
                }
            }
            System.out.println("util.reuslt："+result);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return result;
    }
}
 
  
Dao层接口
 
  
//查询接口-查询结果高亮
    public List searchResultHighLight(String[] queryies, String[] fields,Class clazz) throws IOException, Exception;
 
  
接口实现
 
  
@Override
    public List searchResultHighLight(String[] queryies, String[] fields, Class clazz) throws IOException, Exception {

        List reObject = new ArrayList<>();

        IndexReader indexReader = DirectoryReader.open(directory);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);

        //多条件
        Query query = MultiFieldQueryParser.parse(queryies,fields,Configuration.ANALYZER);
        //单条件查询--创建查询解析器
        /*QueryParser queryParser = new QueryParser("goodsName",Configuration.ANALYZER);
        Query query = queryParser.parse(qureyString);*/

        //执行查询--设置返回最多条数
        TopDocs topDocs = indexSearcher.search(query,10);

        long conut = topDocs.totalHits;
        System.out.println("检索总条数："+conut);

        //根据文档编号遍历真正的文档
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        for (ScoreDoc scoreDoc : scoreDocs) {

            Document document = indexSearcher.doc(scoreDoc.doc);
            System.out.println("相关度："+scoreDoc.score);

            //将文档对象转成javaBean
            Object object = BeanUtils.documentToBean(document,clazz);

            //设置高亮
            for(String fieldName : fields){
                String highLightResult = HighLightUtil.doHighLight(query,fieldName, document.get(fieldName), 5);

                org.apache.commons.beanutils.BeanUtils.setProperty(object, fieldName,
                        highLightResult);
            }

            reObject.add(object);
        }

        return reObject;
    } 
  
测试
 
  
//测试高亮显示查询
    @Test
    public void testSearchResultHighLight() throws Exception {
        List reGoods = luceneDao.searchResultHighLight(new String[]{"小米"},new String[]{"goodsName"},Goods.class);
        reGoods.forEach(v->System.out.println(v.toString()));
    }
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Lucene,案例,Lucene,Java_jsp)

        

            

                
    
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    
                    
    • 
                    
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • Kafka 消息丢失如何处理？
                        架构文摘JGWZ
学习
                        
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
    
                    
    • 
                    
  • 走向以教育叙事为载体的教育叙事研究
                        666小飞鱼

                        
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
    
                    
    • 
                    
  • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    
                    
    • 
                    
  • 《Python数据分析实战终极指南》
                        xjt921122
python数据分析开发语言
                        
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
    
                    
    • 
                    
  • 2022-08-28
                        蔚蓝一片晴

                        
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
    
                    
    • 
                    
  • 多子女家庭问题
                        3e5c5362403c

                        
    杨宁宁焦点解决网络初17中19坚持分享589天（2021.3.20）本周约练我1次，总计166次，读书打卡第256天案例督导收获：【家有老大篇】被爱与高期待下的独舞家里的第一个孩子往往集万千宠爱于一身。爸爸妈妈、爷爷奶奶、姥姥姥爷的目光都聚焦在他的身上。在这种光环下长大的孩子，就如小皇帝一般，衣来伸手、饭来张口。拥有爱的同时，也意味着拥有了更高的被期待，父母会花血本给你报各种各样的早教班，给你买各
    
                    
    • 
                    
  • 第二十 python基础--语句
                        九樱MOL

                        
    目录具体内容1：if语句的使用格式判断语句2：if-else的使用格式3：if-elif-else的使用格式4：if嵌套1：while循环的格式循环语句2：while循环嵌套3：for循环的格式一、判断语句在程序中如果某些条件满足，才能做某件事情，而不满足时不允许做，这就是所谓的判断1.1if语句的使用格式if要判断的条件:条件成立时，要做的事情案例:判断年纪，如果age大于18，输入成年age=
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 为什么学生不喜欢上学
                        虾虾说

                        
    图片发自App《为什么学生不喜欢上学》作者是丹尼尔·威林厄姆。本书从认知心理学角度，结合大量实证案例，阐释了大脑工作的基本原理，回答了关于学习过程的一系列问题。为什么学生不喜欢上学？——大脑工作的基本原理思考是缓慢的、费力的、不可靠的。思考有三个要素，环境、工作记忆和长期记忆。环境是信息来源；长期记忆是知识、经验的巨型仓库，随时可以调取；工作记忆是中央处理器，是加工信息素材的中央厨房，也是思考过程
    
                    
    • 
                    
  • Python数据分析与可视化
                        jun778895
python数据分析开发语言
                        
    Python数据分析与可视化是一个涉及数据处理、分析和以图形化方式展示数据的过程，它对于数据科学家、分析师以及任何需要从数据中提取洞察力的专业人员来说至关重要。以下将详细探讨Python在数据分析与可视化方面的应用，包括常用的库、数据处理流程、可视化技巧以及实际应用案例。一、Python数据分析与可视化的重要性数据可视化是将数据以图形或图像的形式表示出来，以便人们能够更直观地理解数据背后的信息和规
    
                    
    • 
                    
  • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15）
                        知识分享小能手
大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
                        
    1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
    
                    
    • 
                    
  • 2021.9.26 王老师直播笔记
                        wan恋空

                        
    案例一孩子想要iPad，爸爸妈妈不同意，孩子在家闹平时老公暴躁会摔手机，孩子会不尊重骂自己总结问题老公儿子很任性1.注意力放到老公和自己的身上一个成熟比较横的男人，需要一个成熟比较理智的女人。2.做好自己的角色*儿子你必须尊重我，接受原则做事。少说教，多谈感受3.找一群志同道合的朋友聊聊，改变圈子案例二女儿六岁觉得老师讲课有问题指出来。做事要有策略六岁可以指出来，六岁以后就不可以了女儿小时候在姥姥
    
                    
    • 
                    
  • 40岁的java程序员，还有出路吗？
                        cesske
java开发语言
                        
    目录前言一、现状与挑战二、出路与机遇三、案例分析与启示四、结语前言40岁Java程序员的出路：挑战与机遇并存在科技日新月异的今天，IT行业始终保持着高速的发展态势，而Java作为其中的重要一员，其地位依然稳固且充满挑战。对于一位40岁的Java程序员而言，面对职业生涯的“中年危机”，是否还有出路？本文将从多个维度探讨这一问题，旨在为这一群体提供思考和启示。一、现状与挑战职场竞争加剧随着技术的不断发
    
                    
    • 
                    
  • KVM+GFS分布式存储系统构建KVM高可用
                        henan程序媛
分布式GFS高可用KVM
                        
    一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
    
                    
    • 
                    
  • Hadoop架构
                        henan程序媛
hadoop大数据分布式
                        
    一、案列分析1.1案例概述现在已经进入了大数据(BigData)时代，数以万计用户的互联网服务时时刻刻都在产生大量的交互，要处理的数据量实在是太大了，以传统的数据库技术等其他手段根本无法应对数据处理的实时性、有效性的需求。HDFS顺应时代出现，在解决大数据存储和计算方面有很多的优势。1.2案列前置知识点1.什么是大数据大数据是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的大量数据集合，
    
                    
    • 
                    
  • 开发游戏的学习规划
                        杰克逊的日记
游戏学习
                        
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
    
                    
    • 
                    
  • 【Python基础】Python迭代器与生成器（两种强大工具）
                        姑苏老陈
Python编程入门python开发语言python迭代器与生成器
                        
    本文收录于《Python编程入门》专栏，从零基础开始，分享一些Python编程基础知识，欢迎关注，谢谢！文章目录一、前言二、迭代器2.1创建迭代器2.2自定义迭代器2.3处理大型文件三、生成器四、生成器表达式五、实际应用案例5.1数据库查询5.2网络数据流处理六、总结一、前言在Python中，迭代器与生成器是两种非常强大的工具，它们可以帮助我们有效地处理大量数据，特别是在需要逐个访问元素的情况下。
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 尹吭【谦虚组】精进打卡2018.06.12
                        老黑1983

                        
    内容：【日精进打卡第171天】【知～学习】《六项精进》2遍共330遍《大学》2遍共346遍••••••【经典名句分享】人不知而不愠不亦君子乎【行～实践】一、修身：（对自己个人）俯卧撑20个五组修身：（利他：告知中医的一些治疗项目）修身：（帮扶：帮扶对象离职）二、齐家：（对家庭和家人）1、送女儿上学三、建功：（对工作）1、湿疹和疣案例页调整｛积善｝：发愿从2017年12月25日起1年内365善事。今
    
                    
    • 
                    
  • 创设问题情境的策略
                        平常心666

                        
    创设情境要有情趣案例：可以圈多少地如何让孩子喜欢数学，是数学教师必须思考和解决的问题。有趣的情境会吸引学生，使学生主动走近数学学习。因此，教师要结合学生的年龄特点和实际生活，创造出富有数学情趣的情境。创设情境要有生活案例：克与千克的生活情境正如著名数学家华罗庚所说：“宇宙之大，粒子之微，火箭之速，化工之巧，地球之变，日月之繁，无处不用数学。”数学与现实生活有着密切的联系。创设情境要有问题案例：喝出
    
                    
    • 
                    
  • Python OpenCV图像处理：从基础到高级的全方位指南
                        极客代码
玩转Python开发语言pythonopencv图像处理计算机视觉
                        
    目录第一部分：PythonOpenCV图像处理基础1.1OpenCV简介1.2PythonOpenCV安装1.3实战案例：图像显示与保存1.4注意事项第二部分：PythonOpenCV图像处理高级技巧2.1图像变换2.2图像增强2.3图像复原第三部分：PythonOpenCV图像处理实战项目3.1图像滤波3.2图像分割3.3图像特征提取第四部分：PythonOpenCV图像处理注意事项与优化策略4
    
                    
    • 
                    
  • MATLAB语言基础教程、 小项目1：简单的计算器、 小项目2：有页面的计算器、使用App Designer创建GUI计算器
                        azuredragonz
学习教程matlab开发语言
                        
    MATLABMATLAB语言基础教程1.MATLAB简介2.基本语法变量与赋值向量与矩阵矩阵运算数学函数控制流3.函数4.绘图案例：简单方程求解小项目1：简单的科学计算器功能代码项目说明小项目2：有页面的计算器使用AppDesigner创建GUI计算器主要步骤：完整代码（使用MATLAB编写）说明：如何运行：小项目总结MATLAB语言基础教程1.MATLAB简介MATLAB（矩阵实验室）是一种用于
    
                    
    • 
                    
  • 增长黑客和最小可复制的内核
                        爱思考的糖

                        
    五段-增长黑客的三大步骤生活就像逆水行舟，加入你不能加速，现实中最好的情况，你也就处在一种原地打转的状况。增长，就像一辆车里的加速器。围棋爱好者，水平一直没有进步的原因。是因为没有找到提高下棋水平的增长模式有三个办法可以提高：做死活题，练习做关键决策的能力；打谱，复盘经典案例；找AI陪练。增长黑客的三个实战步骤：第一步，假设：建立最小闭环。从笨办法开始，不怕犯错，代价并不高，你可以勇敢尝试。想知道
    
                    
    • 
                    
  • python使用MD5
                        18.程序员
哈希算法算法
                        
    一、要使用Python进行MD5加密，可以使用Python标准库中的hashlib模块。二、案例importhashlibstring="Hello,World!"#要进行加密的字符串hash_object=hashlib.md5(string.encode())#将字符串编码并进行MD5加密hash_hex=hash_object.hexdigest()#获取加密后的十六进制字符串print(h
    
                    
    • 
                    
  • 深入理解AOP（面向切面编程）及其应用
                        自身就是太阳
java开发语言spring
                        
    目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
    
                    
    • 
                                
  • Spring中@Value注解，需要注意的地方
                                    无量
springbean@Valuexml
                                    
    Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 
 
 
1、在applicationContext.xml文件(或引用文件中)中配置properties文件 
 
<bean id="appProperty"
    class="org.springframework.beans.fac
    
                                
    • 
                                
  • mongoDB 分片
                                    开窍的石头
mongodb
                                    
        mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。 
    第一步启动两台以上的mongo服务 
&nb
    
                                
    • 
                                
  • OVER(PARTITION BY)函数用法
                                    0624chenhong
oracle
                                    
    这篇写得很好，引自 
http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html 
 
 
OVER(PARTITION BY)函数用法 
 
 2010年10月26日 
 
OVER(PARTITION BY)函数介绍 
 
开窗函数        &nb
    
                                
    • 
                                
  • Android开发中，ADB server didn't ACK 解决方法
                                    一炮送你回车库
Android开发
                                    
    首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。 
  
一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 
参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 
简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 
&nb
    
                                
    • 
                                
  • canvas中的像素绘制问题
                                    换个号韩国红果果
JavaScriptcanvas
                                    
    pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 
2.如果绘制点为一个像素的
    
                                
    • 
                                
  • 编码乱码问题
                                    灵静志远
javajvmjsp编码
                                    
    1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 
3、getBytes()、getByte
    
                                
    • 
                                
  • java 求几个月后的日期
                                    darkranger
calendargetinstance
                                    
    Date plandate = planDate.toDate();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(plandate);
// 取得三个月后时间
cal.add(Calendar.M
    
                                
    • 
                                
  • 数据库设计的三大范式（通俗易懂）
                                    aijuans
数据库复习
                                    
    关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 
目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
    
                                
    • 
                                
  • 想学工作流怎么入手
                                    atongyeye
jbpm
                                    
    工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 
 
 
系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 
 
本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 
 
1  首先要
    
                                
    • 
                                
  • Context和SQLiteOpenHelper创建数据库
                                    百合不是茶
androidContext创建数据库
                                    
           一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 
  
  
一:SQLiteOpenHelper创建数据库: 
  
1,SQLi
    
                                
    • 
                                
  • 浅谈group by和distinct
                                    bijian1013
oracle数据库group bydistinct
                                    
            group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。 
        譬如：统计每id数并且只显示数大于3 
select id ,count(id) from ta
    
                                
    • 
                                
  • vi opertion
                                    征客丶
macoprationvi
                                    
    进入 command mode （命令行模式） 
按 esc 键 
再按 shift + 冒号 
 
注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 
 
一、文件操作 
1.1、强制退出不保存 
$ q! 
1.2、保存 
$ w 
1.3、保存并退出 
$ wq 
1.4、刷新或重新加载已打开的文件 
$ e 
 
二、光标移动 
2.1、跳到指定行 
数字
    
                                
    • 
                                
  • 【Spark十四】深入Spark RDD第三部分RDD基本API
                                    bit1129
spark
                                    
      
对于K/V类型的RDD,如下操作是什么含义？ 
  
val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5))
rdd.reduceByKey(_+_).collect 
 reduceByKey在这里的操作，是把
    
                                
    • 
                                
  • java类加载机制
                                    BlueSkator
java虚拟机
                                    
    java类加载机制 
1.java类加载器的树状结构 
引导类加载器 
^ 
| 
扩展类加载器 
^ 
| 
系统类加载器 
java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 
虚拟机区分一个Cla
    
                                
    • 
                                
  • 动态添加文本框
                                    BreakingBad
文本框
                                    
      <script>     var num=1; function AddInput() {      var str="";     str+="<input 
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-单例模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



public class Singleton {
}

/*
 * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题
 */
class LazySingleton
    
                                
    • 
                                
  • iOS应用打包发布常见问题
                                    chenhbc
iosiOS发布iOS上传iOS打包
                                    
    这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 
  
1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
    
                                
    • 
                                
  • 工作流复杂拓扑结构处理新思路
                                    comsci
设计模式工作算法企业应用OO
                                    
     我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
    
                                
    • 
                                
  • oracle 11g新特性Flashback data archive
                                    daizj
oracle
                                    
    1. 什么是flashback data archive 
 
Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。 
    
                                
    • 
                                
  • 多叉树:2-3-4树
                                    dieslrae
树
                                    
        平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 
    1、有一个数据项的节点总是有2个子节点(称为2-节点) 
    2、有两个数据项的节点总是有3个子节点(称为3-节
    
                                
    • 
                                
  • C语言学习七动态分配 malloc的使用
                                    dcj3sjt126com
clanguagemalloc
                                    
    /*
	2013年3月15日15:16:24
	malloc 就memory(内存) allocate(分配)的缩写
	本程序没有实际含义，只是理解使用	
 */
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int i = 5;	//分配了4个字节 静态分配
	int * p 
    
                                
    • 
                                
  • Objective-C编码规范[译]
                                    dcj3sjt126com
代码规范
                                    
         
 
  
  原文链接 : The official raywenderlich.com Objective-C style guide  
  原文作者 : raywenderlich.com Team  
  译文出自 : raywenderlich.com Objective-C编码规范  
  译者 : Sam Lau  
  
    
                                
    • 
                                
  • 0.性能优化-目录
                                    frank1234
性能优化
                                    
    从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 
主要内容包括： 
一、性能测试指标 
吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 
http://frank1234.iteye.com/blog/2180305 
 
二、性能测试策略 
生产环境相同 基准测试 预热等 
htt
    
                                
    • 
                                
  • Java父类取得子类传递的泛型参数Class类型
                                    happyqing
java泛型父类子类Class
                                    
      
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

abstract class BaseDao<T> {
	public void getType() {
		//Class<E> clazz =
    
                                
    • 
                                
  • 跟我学SpringMVC目录汇总贴、PDF下载、源码下载
                                    jinnianshilongnian
springMVC
                                    
      
----广告-------------------------------------------------------------- 
网站核心商详页开发 
掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 
掌握数据库技术，表设计和索引优化，分库分表/读写分离； 
了解缓存技术，熟练使用如Redis/Memcached等主流技术； 
了解Ngin
    
                                
    • 
                                
  • the HTTP rewrite module requires the PCRE library
                                    流浪鱼
rewrite
                                    
    ./configure: error: the HTTP rewrite module requires the PCRE library. 
模块依赖性Nginx需要依赖下面3个包 
1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 
2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 
3. s
    
                                
    • 
                                
  • 第12章 Ajax（中）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Optimize query with Query Stripping in Web Intelligence
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence 
and a very straightfoward video 
http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
    
                                
    • 
                                
  • Java开发者写SQL时常犯的10个错误
                                    tomcat_oracle
javasql
                                    
    1、不用PreparedStatements   　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：   　　他们对PreparedStatements不了解   　　他们认为使用PreparedStatements太慢了   　　他们认为写Prepar
    
                                
    • 
                                
  • 世纪互联与结盟有感
                                    阿尔萨斯

                                    
     10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 
 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 
 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
    
                                
    •