SOLRJ单机-添加文档，删除，查询操作

单机solrJ不需要占用太多的服务器和资源，本机使用solr-6.3.0,也不需要配置tomcat.

一、新建一个java工程需要依赖的jar包如下：

solr-solrj-6.3.0.jar;  commons-lang-2.5.jar  ; log4j-1.2.17.jar; slf4j-api-1.7.7.jar; slf4j-log4j12-1.7.6.jar;httpclient-4.4.1.jar; httpcore-4.4.1.jar; httpmime-4.4.1.jar

(解析json常用的包:commons-logging-1.1.1.jar;commons-beanutils-1.7.jar;commons-collections.jar; noggit-0.5.jar; ezmorph.jar; json-lib-2.2.2-jdk15.jar;)

二、文档操作（增加，删除，查询）的代码如下：

1.首先创建一个对象，对象只有一些属性值，没有成员方法。

 package test;

 public class LawTest {
     // String fields[]={"guid","lawName","itemIndex","itemTitle","itemContent","categoryTitle","categoryIndex"};
      private String guid;
      private String lawName;
      private int itemIndex;
      private String itemTitle;
      private String itemContent;
      private String categoryTitle;
      private int categoryIndex;
      public LawTest(){
          this.guid="";
          this.lawName="";
          this.itemIndex=0;
          this.itemTitle="";
          this.itemContent="";
          this.categoryTitle="";
          this.categoryIndex=0;
      }
      public LawTest(String guid,String lawName,int itemIndex,String itemTitle,String itemContent,String categoryTitle,int categoryIndex){
          this.guid=guid;
          this.lawName=lawName;
          this.itemIndex=itemIndex;
          this.itemTitle=itemTitle;
          this.itemContent=itemContent;
          this.categoryTitle=categoryTitle;
          this.categoryIndex=categoryIndex;
      }
     public String getGuid() {
         return guid;
     }
     public void setGuid(String guid) {
         this.guid = guid;
     }
     public String getLawName() {
         return lawName;
     }
     public void setLawName(String lawName) {
         this.lawName = lawName;
     }
     public int getItemIndex() {
         return itemIndex;
     }
     public void setItemIndex(int itemIndex) {
         this.itemIndex = itemIndex;
     }
     public String getItemTitle() {
         return itemTitle;
     }
     public void setItemTitle(String itemTitle) {
         this.itemTitle = itemTitle;
     }
     public String getItemContent() {
         return itemContent;
     }
     public void setItemContent(String itemContent) {
         this.itemContent = itemContent;
     }
     public String getCategoryTitle() {
         return categoryTitle;
     }
     public void setCategoryTitle(String categoryTitle) {
         this.categoryTitle = categoryTitle;
     }
     public int getCategoryIndex() {
         return categoryIndex;
     }
     public void setCategoryIndex(int categoryIndex) {
         this.categoryIndex = categoryIndex;
     }

 }

2.有了对象后，开始构建我们的客户端代码：首先初始化连接

     private static String serverUrl="http://localhost:8983/solr/collectionTest";
     private static String fields[]={"guid","lawName","itemIndex","itemTitle","itemContent","categoryTitle","categoryIndex"};
     private static SolrClient solrclient = null;
     private static SolrQuery query=new SolrQuery("*:*");
     /**
      * 初始化连接
      */
     @SuppressWarnings("deprecation")
     public static void initiate(){
           solrclient = new HttpSolrClient(serverUrl);
     }

3.  然后需要将已有的入库json文本转化为对象，再根据对象添加到solr中

 /**
  * 输入文档存放地址，读取为字符串
  * 将字符串解析为json并转换为对象
  * @param DirectoryPath
  * @return
  */
     public static List<LawTest> readTxtFile(String DirectoryPath){
         List<LawTest> list = new ArrayList<LawTest>();
         try {
                 String encoding="GB2312";//UTF-8
                 String guid=null;
                 String lawName=null;
                 int itemIndex=0;
                 String itemTitle=null;
                 String itemContent=null;
                 String categoryTitle=null;
                 int categoryIndex=0;
                 File file=new File(DirectoryPath);
                 File[] tempList = file.listFiles();
                 System.out.println("该目录下对象个数："+tempList.length);
                 for (int i = 0; i < tempList.length; i++) {
                  if (tempList[i].isFile() && tempList[i].exists()) {
                       //保存每一个文本为字符串
                       StringBuilder stringAll=new StringBuilder();
                       System.out.println("文 件："+i+":"+tempList[i]);
                       InputStreamReader read = new InputStreamReader(
                       new FileInputStream(tempList[i]),encoding);//考虑到编码格式
                       BufferedReader bufferedReader = new BufferedReader(read);
                       String lineTxt = null;
                       while((lineTxt = bufferedReader.readLine()) != null){
                           System.out.println(lineTxt);
                           stringAll.append(lineTxt);
                       }
                       String text=stringAll.toString();
                       JSONArray arry = JSONArray.fromObject(text);
                       System.out.println("json字符串内容如下");
                       System.out.println(arry);
                       //List<Map<String, String>> rsList = new ArrayList<Map<String, String>>();
                       for (int j = 0; j < arry.size(); j++)
                       {
                           JSONObject jsonObject = arry.getJSONObject(j);
                           //Map<String, String> map = new HashMap<String, String>();
                           for (Iterator<?> iter = jsonObject.keys(); iter.hasNext();)
                           {
                               String key = (String) iter.next();
                               String value = jsonObject.get(key).toString();
                              // map.put(key, value);
                               if("guid".equals(key)){ guid=value; }
                               else if("lawName".equals(key)){ lawName=value;}
                               else if("itemIndex".equals(key)){ itemIndex=Integer.valueOf(value);}
                               else if("itemTitle".equals(key)){ itemTitle=value;}
                               else if("itemContent".equals(key)){ itemContent=value;}
                               else if("categoryIndex".equals(key)){ categoryIndex=Integer.valueOf(value);}
                               else if("categoryTitle".equals(key)){ categoryTitle=value;}

                           }
                           LawTest lawlistbean=new LawTest( guid, lawName, itemIndex, itemTitle, itemContent, categoryTitle, categoryIndex);
                           list.add(lawlistbean);
                           //rsList.add(map);
                       }
                  }
              }
         }
         catch (Exception e) {
             System.out.println("读取文件内容出错");
             e.printStackTrace();
         }
         return list;

     }

4.添加文档：

  /**
      * 添加文档
      * @param DocList
      */
     public static  void addDocs(List<LawTest> DocList) {
         try {
             for (int i = 0; i<DocList.size();i++){
                 SolrInputDocument doc1=new SolrInputDocument();
                 doc1.setField("guid", DocList.get(i).getGuid());
                 doc1.setField("lawName", DocList.get(i).getLawName());
                 doc1.setField("itemIndex", DocList.get(i).getItemIndex());
                 doc1.setField("itemTitle", DocList.get(i).getItemTitle());
                 doc1.setField("itemContent", DocList.get(i).getItemContent());
                 doc1.setField("categoryIndex", DocList.get(i).getCategoryIndex());
                 doc1.setField("categoryTitle", DocList.get(i).getItemTitle());
                 solrclient.add(doc1);
             }
         }catch (Exception e) {
                 e.printStackTrace();
             } finally {
                 try {
                     solrclient.commit();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
     } 

5.删除文档;

 /**
      * 根据索引删除文档
      * @param query
      */
     public void delDoc(String query){
       try {
              solrclient.deleteByQuery(query);
              solrclient.commit();
             } catch (Exception e) {
                 e.printStackTrace();
             }

     }

6.查询文档;

    /**
     * 查询文档
     * @param query
     */
    public static List<Map<String,Object>> queryDoc(SolrQuery query, String[] fields){
        if(query==null || fields==null){
            return null;
        }
        else{
            QueryResponse resp3 = null;
            query.setStart(0);
            query.setRows(10);
            query.setFields(fields);
             try {
                resp3=solrclient.query(query);
            } catch (SolrServerException | IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

             SolrDocumentList solrList = resp3.getResults();
             List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
            for (SolrDocument doc : solrList) {
                Map<String, Object> resultMap=new HashMap<String, Object>();
                for (String field : fields){
                    resultMap.put(field,doc.get(field));
                }
                    result.add(resultMap);
            }
            return result;
        }
    }
    //查询文档入口
    public static List<Map<String,Object>> retrieveContent(Map<String, Object> args){
        //关键词
        String keywords = (String) args.remove("keyword");
        if (!(keywords == null || "".equals(keywords))) {
            query.setQuery(keywords);
        }
        //其他查询过滤条件
        for (Entry<String, Object> entry : args.entrySet()) {
            query.addFilterQuery(entry.getKey() + ":" + entry.getValue());
        }
        return queryDoc(query,fields);
    }

7.获取文档数量：

 public static long getCount(){
         long numFound = 0;
         SolrQuery q = query.getCopy();
         q.setStart(0);
         q.setRows(0);
         try {
             //没必要排序
             q.remove("sort");
             if ((query.getBool("group", false))) {
                 q.setParam("group", false);
                 q.setParam("group.ngroups", false);
                 String field = query.get("group.field");
                 q.set("json.facet", "{distinctCount:'unique(" + field + ")'}");
             }
             QueryResponse results = solrclient.query(q,METHOD.POST);
             if ((query.getBool("group", false))) {
                 Object facets = results.getResponse().get("facets");
                 if(facets != null && facets instanceof SimpleOrderedMap){
                     Object distinctCount = ((SimpleOrderedMap)facets).get("distinctCount");
                     if(distinctCount != null ){
                         numFound = (Long)distinctCount;
                     }
                 }
             } else {
                 numFound = results.getResults().getNumFound();
             }
         } catch (SolrServerException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         return numFound;
     }

8.测试主函数：

 public static void main(String [] args) throws SolrServerException, IOException{
         String path="D:\\文件\\solr入库测试文件";
         Map<String, Object> map=new HashMap<String, Object>();
         //初始化
         initiate();
         //添加文档测试
         //addDocs(readTxtFile(path));
         //查询
         map.put("keyword", "标题");
         List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
         result=retrieveContent(map);
         if(result==null || result.size()==0){
             System.out.println("data is null");
         }
         else{
             System.out.println("-----输出查询结果如下：-----\n");
             result.forEach( mp->{
                 for(String key: mp.keySet()){
                     System.out.println(key+":"+mp.get(key).toString());
                 }

             });
         }
         System.out.println("query count:"+getCount());
         System.out.println("query over!");

     }