solrj 实现多字段分组统计查询(facet)

xingyu655

import java.io.IOException;　　

import java.io.InputStream;　　

import java.text.SimpleDateFormat;　　

import java.util.Calendar;　　

import java.util.Date;　　

import java.util.HashMap;　　

import java.util.LinkedHashMap;　　

import java.util.List;　　

import java.util.Map;　　

　　
import org.apache.ibatis.io.Resources;
　　
import org.apache.ibatis.session.SqlSession;
　　
import org.apache.ibatis.session.SqlSessionFactory;
　　
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
　　
import org.apache.solr.client.solrj.SolrQuery;
　　
import org.apache.solr.client.solrj.SolrQuery.ORDER;
　　
import org.apache.solr.client.solrj.SolrServerException;
　　
import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrClient;
　　
import org.apache.solr.client.solrj.response.Group;
　　
import org.apache.solr.client.solrj.response.GroupCommand;
　　
import org.apache.solr.client.solrj.response.GroupResponse;
　　
import org.apache.solr.client.solrj.response.PivotField;
　　
import org.apache.solr.client.solrj.response.QueryResponse;
　　
import org.apache.solr.common.SolrDocument;
　　
import org.apache.solr.common.SolrDocumentList;
　　
import org.apache.solr.common.SolrInputDocument;
　　
import org.apache.solr.common.SolrInputField;
　　
import org.apache.solr.common.params.GroupParams;
　　
import org.apache.solr.common.util.NamedList;
　　

　　
import com.daan.sql2solr.domain.ParModule;
　　
import com.daan.sql2solr.domain.ParModuleMapper;
　　
import com.daan.sql2solr.domain.SpecimenInfo;
　　
import com.daan.sql2solr.domain.SpecimenInfoMapper;
　　


　　
public>　　

　　
     static SqlSessionFactory sqlSessionFactory;
　　
     // solr url
　　
     static final String URL = "http://192.168.14.59:8983/solr";
　　
     // solr应用
　　
     static final String SERVER = "khlis_report_info";
　　

　　
     static ConcurrentUpdateSolrClient client = new ConcurrentUpdateSolrClient(URL + "/" + SERVER, 10000, 2);
　　

　　
     public static ConcurrentUpdateSolrClient getSolrClient() {
　　
         // if (client == null) client = new ConcurrentUpdateSolrClient(URL + "/"
　　
         // + SERVER, 10000, 2);
　　
         return client;
　　
     }
　　

　　
     public static void main(String[] args) throws IOException, SolrServerException {
　　
         // TODO Auto-generated method stub
　　
         deleteIndex();
　　
         SqlSession session = getSqlSession().openSession();
　　
         try {
　　
             ParModuleMapper mapper = session.getMapper(ParModuleMapper.class);
　　
             List<ParModule> lstModule = mapper.selectParModuleLst();
　　
//             createIndexBatch(lstModule);
　　
             // for(ParModule item:lstModule){ createIndex(item); }
　　
//             deleteIndex();
　　
//             createIndexRandom();
　　
             // query();
　　
              group();

　　
//            >　　
         } finally {
　　
             session.close();
　　
             getSolrClient().close();
　　
         }
　　
     }
　　

　　
     private static SqlSessionFactory getSqlSession() throws IOException {
　　
         if (sqlSessionFactory == null) {
　　
             String resource = "mybatis-config.xml";
　　
             InputStream inputStream = Resources.getResourceAsStream(resource);
　　
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
　　
             // sqlSessionFactory.getConfiguration().addMapper(ParModuleMapper.class);
　　
         }
　　
         return sqlSessionFactory;
　　
     }
　　

　　
     public static void insertSpecimenBatch(List<SpecimenInfo> items) throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         Map<String, SolrInputField> fields = new LinkedHashMap<>();
　　
         SolrInputField field_testing_forms_id = new SolrInputField("testing_forms_id");
　　
         SolrInputField field_test_time = new SolrInputField("test_time");
　　
         SolrInputField field_barcode = new SolrInputField("barcode");
　　
         SolrInputField field_subject_name = new SolrInputField("subject_name");
　　
         SolrInputField field_sex_name = new SolrInputField("sex_name");
　　
         fields.put(field_testing_forms_id.getName(), field_testing_forms_id);
　　
         fields.put(field_test_time.getName(), field_test_time);
　　
         fields.put(field_barcode.getName(), field_barcode);
　　
         fields.put(field_subject_name.getName(), field_subject_name);
　　
         fields.put(field_sex_name.getName(), field_sex_name);
　　
         SolrInputDocument docSource = new SolrInputDocument(fields);
　　
         for (SpecimenInfo item : items) {
　　
             SolrInputDocument doc = docSource.deepCopy();
　　
             doc.getField(field_testing_forms_id.getName()).setValue(item.getTesting_forms_id(), 1.0f);
　　
             SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
　　
             String dateString = formatter.format(item.getTest_time());
　　
             doc.getField(field_test_time.getName()).setValue(dateString, 1.0f);
　　
             // doc.getField(field_test_time.getName()).setValue(item.getTest_time(),
　　
             // 1.0f);
　　
             doc.getField(field_barcode.getName()).setValue(item.getBarcode(), 1.0f);
　　
             doc.getField(field_subject_name.getName()).setValue(item.getSubject_name(), 1.0f);
　　
             doc.getField(field_sex_name.getName()).setValue(item.getSex_name(), 1.0f);
　　
             client.add(doc);
　　
         }
　　
         client.commit();
　　
     };
　　

　　
     /**
　　
      * 新建索引
　　
      *
　　
      * @throws IOException
　　
      * @throws SolrServerException
　　
      */
　　
     public static void createIndex(ParModule item) throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         Map<String, SolrInputField> fields = new LinkedHashMap<>();
　　
         SolrInputField field_id = new SolrInputField("id");
　　
         SolrInputField field_module_name = new SolrInputField("module_name");
　　
         SolrInputField field_module_code = new SolrInputField("module_code");
　　
         fields.put(field_id.getName(), field_id);
　　
         fields.put(field_module_name.getName(), field_module_name);
　　
         fields.put(field_module_code.getName(), field_module_code);
　　
         SolrInputDocument docSource = new SolrInputDocument(fields);
　　

　　
         SolrInputDocument doc = docSource.deepCopy();
　　
         doc.getField(field_id.getName()).setValue(item.getId(), 1.0f);
　　
         doc.getField(field_module_name.getName()).setValue(item.getModule_name(), 1.0f);
　　
         doc.getField(field_module_code.getName()).setValue(item.getModule_code(), 1.0f);
　　
         client.add(doc);
　　
     };
　　

　　
     public static void createIndexBatch(List<ParModule> items) throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         Map<String, SolrInputField> fields = new LinkedHashMap<>();
　　
         SolrInputField field_id = new SolrInputField("id");
　　
         SolrInputField field_module_name = new SolrInputField("module_name");
　　
         SolrInputField field_module_code = new SolrInputField("module_code");
　　
         SolrInputField field_module_level = new SolrInputField("module_level");
　　
         SolrInputField field_function_type = new SolrInputField("function_type");
　　

　　
         fields.put(field_id.getName(), field_id);
　　
         fields.put(field_module_name.getName(), field_module_name);
　　
         fields.put(field_module_code.getName(), field_module_code);
　　
         fields.put(field_module_level.getName(), field_module_level);
　　
         fields.put(field_function_type.getName(), field_function_type);
　　
         SolrInputDocument docSource = new SolrInputDocument(fields);
　　
         for (ParModule item : items) {
　　
             SolrInputDocument doc = docSource.deepCopy();
　　
             doc.getField(field_id.getName()).setValue(item.getId(), 1.0f);
　　
             doc.getField(field_module_name.getName()).setValue(item.getModule_name(), 1.0f);
　　
             doc.getField(field_module_code.getName()).setValue(item.getModule_code(), 1.0f);
　　
             doc.getField(field_module_level.getName()).setValue(item.getModule_level(), 1.0f);
　　
             doc.getField(field_function_type.getName()).setValue(item.getFunction_type(), 1.0f);
　　
             client.add(doc);
　　
         }
　　
         client.commit();
　　
     };
　　

　　
     public static void createIndexRandom() throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         Map<String, SolrInputField> fields = new LinkedHashMap<>();
　　
         SolrInputField field_id = new SolrInputField("id");
　　
         SolrInputField field_module_name = new SolrInputField("module_name");
　　
         SolrInputField field_module_code = new SolrInputField("module_code");
　　
         fields.put(field_id.getName(), field_id);
　　
         fields.put(field_module_name.getName(), field_module_name);
　　
         fields.put(field_module_code.getName(), field_module_code);
　　
         SolrInputDocument docSource = new SolrInputDocument(fields);
　　
         int max = 100 * 10000;
　　
         for (int i = 1; i < max; i++) {
　　
             SolrInputDocument doc = docSource.deepCopy();
　　
             doc.getField(field_id.getName()).setValue(i, 1.0f);
　　
             doc.getField(field_module_name.getName()).setValue("module_name" + i, 1.0f);
　　
             doc.getField(field_module_code.getName()).setValue("module_code" + i, 1.0f);
　　
             client.add(doc);
　　
         }
　　
         client.commit();
　　
     };
　　

　　
     public static void deleteIndex() throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         client.deleteByQuery("*:*");
　　
         client.commit();
　　
     }
　　

　　
     public static void query() throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         SolrQuery query = new SolrQuery();
　　
         query.setQuery("module_name:*日志*");
　　
         query.setFilterQueries("id:1*");
　　
         query.setStart(0);
　　
         query.setRows(10);
　　
         query.addSort("id", ORDER.desc);
　　
         SolrDocumentList docs = client.query(query).getResults();
　　
         for (SolrDocument sd : docs) {
　　
             System.out.println(sd.getFieldValue("module_name"));
　　
         }
　　
     }
　　

　　
     public static void group() throws SolrServerException, IOException {
　　
         client = getSolrClient();
　　
         SolrQuery query = new SolrQuery();
　　
         query.setQuery("module_name:*");
　　
         query.setParam(GroupParams.GROUP, true);
　　
         // query.setParam(GroupParams.GROUP_FIELD, new
　　
         // String[]{"module_level","function_type"});
　　
         query.setParam(GroupParams.GROUP_FIELD, "function_type", "module_level");
　　
         query.setParam(GroupParams.GROUP_LIMIT, "0");
　　
         query.setParam(GroupParams.GROUP_MAIN, false);
　　
         query.setParam(GroupParams.GROUP_QUERY, "module_level:1", "module_level:2");
　　
         query.setParam(GroupParams.GROUP_LIMIT, "1");
　　
         query.setParam("fq", "id:1*", "function_type:*");
　　
         QueryResponse response = null;
　　
         response = client.query(query);
　　
         Map<String, Integer> info = new HashMap<String, Integer>();
　　
         GroupResponse groupResponse = response.getGroupResponse();
　　
         if (groupResponse != null) {
　　
             List<GroupCommand> groupList = groupResponse.getValues();
　　
             for (GroupCommand groupCommand : groupList) {
　　
                 List<Group> groups = groupCommand.getValues();
　　
                 for (Group group : groups) {
　　
                     System.out.println(group.getGroupValue() + ":" + group.getResult().getNumFound());
　　
                 }
　　
             }
　　
         }
　　
     }
　　


　　
     public static void>　　
         client = getSolrClient();
　　
         SolrQuery query = new SolrQuery();
　　

　　
         query.set("q", "*");
　　
         query.setRows(0);
　　
         query.addGetFieldStatistics("{!tag=dosum sum=true}_version_");
　　
         query.addFacetPivotField("{!stats=dosum}function_type,module_level");
　　
         QueryResponse response = client.query(query);
　　
         NamedList<List<PivotField>> lstFacet = response.getFacetPivot();
　　
         List<PivotField> pfs = lstFacet.get("function_type,module_level");
　　
         for (PivotField pf : pfs) {
　　
             System.out.println("function_type: " + pf.getValue() + " --- count:" + pf.getCount());
　　
             List<PivotField> pfs2 = pf.getPivot();
　　
             for (PivotField pf2 : pfs2) {
　　
                 System.out.print(" module_level:" + pf2.getValue() + " --- count " + pf2.getCount());
　　
                 System.out.println("  _version_  sum:" + pf2.getFieldStatsInfo().get("_version_").getSum());
　　
             }
　　
         }
　　
         System.out.println(response.toString());
　　
     }
　　
}