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

最新推荐文章于 2024-04-07 11:05:22 发布
weixin_30719711
最新推荐文章于 2024-04-07 11:05:22 发布
阅读量1.7k
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/reachlins/p/6560170.html
版权
solr分组统计查询,实现多字段分组统计,网上多是用 group分组,无法实现多字段分组.本例子使用facet实现多字段分组统计,见facet()函数的输出.
从mysql导入一批数据到solr进行测试.
测试用的数据源 ;
  1 import java.io.IOException;
  2 import java.io.InputStream;
  3 import java.text.SimpleDateFormat;
  4 import java.util.Calendar;
  5 import java.util.Date;
  6 import java.util.HashMap;
  7 import java.util.LinkedHashMap;
  8 import java.util.List;
  9 import java.util.Map;
 10 
 11 import org.apache.ibatis.io.Resources;
 12 import org.apache.ibatis.session.SqlSession;
 13 import org.apache.ibatis.session.SqlSessionFactory;
 14 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 15 import org.apache.solr.client.solrj.SolrQuery;
 16 import org.apache.solr.client.solrj.SolrQuery.ORDER;
 17 import org.apache.solr.client.solrj.SolrServerException;
 18 import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrClient;
 19 import org.apache.solr.client.solrj.response.Group;
 20 import org.apache.solr.client.solrj.response.GroupCommand;
 21 import org.apache.solr.client.solrj.response.GroupResponse;
 22 import org.apache.solr.client.solrj.response.PivotField;
 23 import org.apache.solr.client.solrj.response.QueryResponse;
 24 import org.apache.solr.common.SolrDocument;
 25 import org.apache.solr.common.SolrDocumentList;
 26 import org.apache.solr.common.SolrInputDocument;
 27 import org.apache.solr.common.SolrInputField;
 28 import org.apache.solr.common.params.GroupParams;
 29 import org.apache.solr.common.util.NamedList;
 30 
 31 import com.daan.sql2solr.domain.ParModule;
 32 import com.daan.sql2solr.domain.ParModuleMapper;
 33 import com.daan.sql2solr.domain.SpecimenInfo;
 34 import com.daan.sql2solr.domain.SpecimenInfoMapper;
 35 
 36 public class AppMain {
 37 
 38     static SqlSessionFactory sqlSessionFactory;
 39     // solr url
 40     static final String URL = "http://192.168.14.59:8983/solr";
 41     // solr应用
 42     static final String SERVER = "khlis_report_info";
 43 
 44     static ConcurrentUpdateSolrClient client = new ConcurrentUpdateSolrClient(URL + "/" + SERVER, 10000, 2);
 45 
 46     public static ConcurrentUpdateSolrClient getSolrClient() {
 47         // if (client == null) client = new ConcurrentUpdateSolrClient(URL + "/"
 48         // + SERVER, 10000, 2);
 49         return client;
 50     }
 51 
 52     public static void main(String[] args) throws IOException, SolrServerException {
 53         // TODO Auto-generated method stub
 54         deleteIndex();
 55         SqlSession session = getSqlSession().openSession();
 56         try {
 57             ParModuleMapper mapper = session.getMapper(ParModuleMapper.class);
 58             List<ParModule> lstModule = mapper.selectParModuleLst();
 59 //             createIndexBatch(lstModule);
 60             // for(ParModule item:lstModule){ createIndex(item); }
 61 //             deleteIndex();
 62 //             createIndexRandom();
 63             // query();
 64              group();
 65 //             facet();
 66         } finally {
 67             session.close();
 68             getSolrClient().close();
 69         }
 70     }
 71 
 72     private static SqlSessionFactory getSqlSession() throws IOException {
 73         if (sqlSessionFactory == null) {
 74             String resource = "mybatis-config.xml";
 75             InputStream inputStream = Resources.getResourceAsStream(resource);
 76             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 77             // sqlSessionFactory.getConfiguration().addMapper(ParModuleMapper.class);
 78         }
 79         return sqlSessionFactory;
 80     }
 81 
 82     public static void insertSpecimenBatch(List<SpecimenInfo> items) throws SolrServerException, IOException {
 83         client = getSolrClient();
 84         Map<String, SolrInputField> fields = new LinkedHashMap<>();
 85         SolrInputField field_testing_forms_id = new SolrInputField("testing_forms_id");
 86         SolrInputField field_test_time = new SolrInputField("test_time");
 87         SolrInputField field_barcode = new SolrInputField("barcode");
 88         SolrInputField field_subject_name = new SolrInputField("subject_name");
 89         SolrInputField field_sex_name = new SolrInputField("sex_name");
 90         fields.put(field_testing_forms_id.getName(), field_testing_forms_id);
 91         fields.put(field_test_time.getName(), field_test_time);
 92         fields.put(field_barcode.getName(), field_barcode);
 93         fields.put(field_subject_name.getName(), field_subject_name);
 94         fields.put(field_sex_name.getName(), field_sex_name);
 95         SolrInputDocument docSource = new SolrInputDocument(fields);
 96         for (SpecimenInfo item : items) {
 97             SolrInputDocument doc = docSource.deepCopy();
 98             doc.getField(field_testing_forms_id.getName()).setValue(item.getTesting_forms_id(), 1.0f);
 99             SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
100             String dateString = formatter.format(item.getTest_time());
101             doc.getField(field_test_time.getName()).setValue(dateString, 1.0f);
102             // doc.getField(field_test_time.getName()).setValue(item.getTest_time(),
103             // 1.0f);
104             doc.getField(field_barcode.getName()).setValue(item.getBarcode(), 1.0f);
105             doc.getField(field_subject_name.getName()).setValue(item.getSubject_name(), 1.0f);
106             doc.getField(field_sex_name.getName()).setValue(item.getSex_name(), 1.0f);
107             client.add(doc);
108         }
109         client.commit();
110     };
111 
112     /**
113      * 新建索引
114      *
115      * @throws IOException
116      * @throws SolrServerException
117      */
118     public static void createIndex(ParModule item) throws SolrServerException, IOException {
119         client = getSolrClient();
120         Map<String, SolrInputField> fields = new LinkedHashMap<>();
121         SolrInputField field_id = new SolrInputField("id");
122         SolrInputField field_module_name = new SolrInputField("module_name");
123         SolrInputField field_module_code = new SolrInputField("module_code");
124         fields.put(field_id.getName(), field_id);
125         fields.put(field_module_name.getName(), field_module_name);
126         fields.put(field_module_code.getName(), field_module_code);
127         SolrInputDocument docSource = new SolrInputDocument(fields);
128 
129         SolrInputDocument doc = docSource.deepCopy();
130         doc.getField(field_id.getName()).setValue(item.getId(), 1.0f);
131         doc.getField(field_module_name.getName()).setValue(item.getModule_name(), 1.0f);
132         doc.getField(field_module_code.getName()).setValue(item.getModule_code(), 1.0f);
133         client.add(doc);
134     };
135 
136     public static void createIndexBatch(List<ParModule> items) throws SolrServerException, IOException {
137         client = getSolrClient();
138         Map<String, SolrInputField> fields = new LinkedHashMap<>();
139         SolrInputField field_id = new SolrInputField("id");
140         SolrInputField field_module_name = new SolrInputField("module_name");
141         SolrInputField field_module_code = new SolrInputField("module_code");
142         SolrInputField field_module_level = new SolrInputField("module_level");
143         SolrInputField field_function_type = new SolrInputField("function_type");
144 
145         fields.put(field_id.getName(), field_id);
146         fields.put(field_module_name.getName(), field_module_name);
147         fields.put(field_module_code.getName(), field_module_code);
148         fields.put(field_module_level.getName(), field_module_level);
149         fields.put(field_function_type.getName(), field_function_type);
150         SolrInputDocument docSource = new SolrInputDocument(fields);
151         for (ParModule item : items) {
152             SolrInputDocument doc = docSource.deepCopy();
153             doc.getField(field_id.getName()).setValue(item.getId(), 1.0f);
154             doc.getField(field_module_name.getName()).setValue(item.getModule_name(), 1.0f);
155             doc.getField(field_module_code.getName()).setValue(item.getModule_code(), 1.0f);
156             doc.getField(field_module_level.getName()).setValue(item.getModule_level(), 1.0f);
157             doc.getField(field_function_type.getName()).setValue(item.getFunction_type(), 1.0f);
158             client.add(doc);
159         }
160         client.commit();
161     };
162 
163     public static void createIndexRandom() throws SolrServerException, IOException {
164         client = getSolrClient();
165         Map<String, SolrInputField> fields = new LinkedHashMap<>();
166         SolrInputField field_id = new SolrInputField("id");
167         SolrInputField field_module_name = new SolrInputField("module_name");
168         SolrInputField field_module_code = new SolrInputField("module_code");
169         fields.put(field_id.getName(), field_id);
170         fields.put(field_module_name.getName(), field_module_name);
171         fields.put(field_module_code.getName(), field_module_code);
172         SolrInputDocument docSource = new SolrInputDocument(fields);
173         int max = 100 * 10000;
174         for (int i = 1; i < max; i++) {
175             SolrInputDocument doc = docSource.deepCopy();
176             doc.getField(field_id.getName()).setValue(i, 1.0f);
177             doc.getField(field_module_name.getName()).setValue("module_name" + i, 1.0f);
178             doc.getField(field_module_code.getName()).setValue("module_code" + i, 1.0f);
179             client.add(doc);
180         }
181         client.commit();
182     };
183 
184     public static void deleteIndex() throws SolrServerException, IOException {
185         client = getSolrClient();
186         client.deleteByQuery("*:*");
187         client.commit();
188     }
189 
190     public static void query() throws SolrServerException, IOException {
191         client = getSolrClient();
192         SolrQuery query = new SolrQuery();
193         query.setQuery("module_name:*日志*");
194         query.setFilterQueries("id:1*");
195         query.setStart(0);
196         query.setRows(10);
197         query.addSort("id", ORDER.desc);
198         SolrDocumentList docs = client.query(query).getResults();
199         for (SolrDocument sd : docs) {
200             System.out.println(sd.getFieldValue("module_name"));
201         }
202     }
203 
204     public static void group() throws SolrServerException, IOException {
205         client = getSolrClient();
206         SolrQuery query = new SolrQuery();
207         query.setQuery("module_name:*");
208         query.setParam(GroupParams.GROUP, true);
209         // query.setParam(GroupParams.GROUP_FIELD, new
210         // String[]{"module_level","function_type"});
211         query.setParam(GroupParams.GROUP_FIELD, "function_type", "module_level");
212         query.setParam(GroupParams.GROUP_LIMIT, "0");
213         query.setParam(GroupParams.GROUP_MAIN, false);
214         query.setParam(GroupParams.GROUP_QUERY, "module_level:1", "module_level:2");
215         query.setParam(GroupParams.GROUP_LIMIT, "1");
216         query.setParam("fq", "id:1*", "function_type:*");
217         QueryResponse response = null;
218         response = client.query(query);
219         Map<String, Integer> info = new HashMap<String, Integer>();
220         GroupResponse groupResponse = response.getGroupResponse();
221         if (groupResponse != null) {
222             List<GroupCommand> groupList = groupResponse.getValues();
223             for (GroupCommand groupCommand : groupList) {
224                 List<Group> groups = groupCommand.getValues();
225                 for (Group group : groups) {
226                     System.out.println(group.getGroupValue() + ":" + group.getResult().getNumFound());
227                 }
228             }
229         }
230     }
231 
232     public static void facet() throws SolrServerException, IOException {
233         client = getSolrClient();
234         SolrQuery query = new SolrQuery();
235 
236         query.set("q", "*");
237         query.setRows(0);
238         query.addGetFieldStatistics("{!tag=dosum sum=true}_version_");
239         query.addFacetPivotField("{!stats=dosum}function_type,module_level");
240         QueryResponse response = client.query(query);
241         NamedList<List<PivotField>> lstFacet = response.getFacetPivot();
242         List<PivotField> pfs = lstFacet.get("function_type,module_level");
243         for (PivotField pf : pfs) {
244             System.out.println("function_type: " + pf.getValue() + " --- count:" + pf.getCount());
245             List<PivotField> pfs2 = pf.getPivot();
246             for (PivotField pf2 : pfs2) {
247                 System.out.print(" module_level:" + pf2.getValue() + " --- count " + pf2.getCount());
248                 System.out.println("  _version_  sum:" + pf2.getFieldStatsInfo().get("_version_").getSum());
249             }
250         }
251         System.out.println(response.toString());
252     }
253 }