Solr 检索结果集List＜SolrDocument＞ 转换为指定业务对象总结

最新推荐文章于 2024-04-07 11:30:23 发布
最新推荐文章于 2024-04-07 11:30:23 发布
阅读量966 收藏
点赞数 1
分类专栏： Java(功能篇) lunece 学习笔记 文章标签： solr lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/123519693
版权

前提说明:从solr结果集中取数据，取到了结果集，但是结果集是一个map，而我想要得到的是一个对象，怎么处理呢? 我总计如下三种方法：

第一种：solrDocument中提供了一个获取每个field对应值的方法,使用此方法获取所有的field对应的值，set到类中：

功能代码如下：

private List<Product> setProductData(SolrDocumentList list) {
        List<Product> datas = new ArrayList<Product>();
        String jsonStr = "";
        Product item = null;
        for (SolrDocument solrDocument : list) {
            item = new Product();
            item.setId((Long)solrDocument.getFieldValue("id"));
            item.setProduct(solrDocument.getFieldValue("product").toString());
            item.setOrderDate((Date)solrDocument.getFieldValue("orderDate"));
            ...
            
            datas.add(item);
        }
        return datas;
    }

第二种：使用了BeanUtils工具+反射，通过反射，获取solrDocument中的所有key和value，然后利用BeanUtils.setProperty(bean, name, value);方法，给Product设置属性，这样也有缺点，就是反射过程中容易出现异常，另外更严重的是此方法对Date类型的属性不能处理，而Product中有Date类型的属性，如果非要使用这种方案，就要写date类型的转换类，无疑增加了代码量。

private List<Product> setProductData(SolrDocumentList list) {
        List<Product> datas = new ArrayList<Product>();
        String jsonStr = "";
        Product item = null;
        for (SolrDocument solrDocument : list) {
            item = new Product();
            Long id =SimpleTypeConverterUtil.convertIfNecessary(solrDocument.getFieldValue("id",Lon.class)
            BeanUtils.setProperty(item, "id", id);
            String product = SimpleTypeConverterUtil.convertIfNecessary(solrDocument.getFieldValue("product",String.class)
            BeanUtils.setProperty(item, "product", product);
            Date orderDate = SimpleTypeConverterUtil.convertIfNecessary(solrDocument.getFieldValue("orderDate,Date.class)
            BeanUtils.setProperty(item, "orderDate", orderDate);
            ...
            
            datas.add(item);
        }
        return datas;
    }
import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.SimpleTypeConverter;

import com.zzg.common.convert.DateEditor;

/**
 * spring type converter 
 * @author Administrator
 *
 */
public class SimpleTypeConverterUtil {
	public static final Logger log = LoggerFactory.getLogger(SimpleTypeConverterUtil.class);
	
	private static final SimpleTypeConverter typeConverterDelegate = new SimpleTypeConverter();
	static{
		typeConverterDelegate.registerCustomEditor(Date.class, new DateEditor());
	}
	
	/**
	 * @param <T>
	 * @param value  待转换值,一般字符串
	 * @param requiredType 转后类型类对象
	 * @return
	 */
	public static <T> T convertIfNecessary(Object value, Class<T> requiredType) {
		T rs = null;
		try {
			rs = typeConverterDelegate.convertIfNecessary(value, requiredType);
		} catch (Exception e) {
			log.info(e.getMessage());
			if(requiredType == int.class || requiredType == Integer.class){
				rs = (T)Integer.valueOf(0);
			}
		}
		return rs;
	}
	
}

package com.zzg.common.convert;

import java.beans.PropertyEditorSupport;

import com.zzg.common.util.DateUtils;

public class DateEditor extends PropertyEditorSupport {
	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		setValue(DateUtils.formatDateStr(text));
	}
}

package com.zzg.common.util;

import java.lang.management.ManagementFactory;
import java.text.DateFormat;
import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 */
public class DateUtils {
	
	public static final Logger log = LoggerFactory.getLogger(DateUtils.class);
	
	public static final String YYYY = "yyyy" ;

    public static final String YYYY_MM = "yyyy-MM" ;

    public static final String YYYY_MM_DD = "yyyy-MM-dd" ;

    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss" ;

    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss" ;

    private static String[] parsePatterns = {
            YYYY_MM_DD , YYYY_MM_DD_HH_MM_SS , "yyyy-MM-dd HH:mm" , YYYY_MM ,
            "yyyy/MM/dd" , "yyyy/MM/dd HH:mm:ss" , "yyyy/MM/dd HH:mm" , "yyyy/MM" ,
            "yyyy.MM.dd" , "yyyy.MM.dd HH:mm:ss" , "yyyy.MM.dd HH:mm" , "yyyy.MM"};

    /**
     * 获取当前Date型日期
     *
     * @return Date() 当前日期
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     *
     * @return String
     */
    public static String getDate() {
        return dateTimeNow(YYYY_MM_DD);
    }

    public static final String getTime() {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }

    public static final String dateTimeNow() {
        return dateTimeNow(YYYYMMDDHHMMSS);
    }

    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }

    public static final String dateTime(final Date date) {
        return parseDateToStr(YYYY_MM_DD, date);
    }

    public static final String parseDateToStr(final String format, final Date date) {
    	if (date == null) {
            return null;
        }

        Format formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }
    
    private static final List<DateFormat> formarts = new ArrayList<>(5);
	static {
		formarts.add(new SimpleDateFormat("yyyy-MM"));
		formarts.add(new SimpleDateFormat("yyyy-MM-dd"));
		formarts.add(new SimpleDateFormat("yyyy-MM-dd hh:mm"));
		formarts.add(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));
		formarts.add(new SimpleDateFormat("yyyy.MM.dd"));
	}

	public static Date formatDateStr(String source) {
		String value = source.trim();
		if ("".equals(value)) {
			return null;
		}
		try {
			if (source.matches("^\\d{4}-\\d{1,2}$")) {
				return formarts.get(0).parse(source);
			} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2}$")) {
				return formarts.get(1).parse(source);
			} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}$")) {
				return formarts.get(2).parse(source);
			} else if (source.matches("^\\d{4}-\\d{1,2}-\\d{1,2} {1}\\d{1,2}:\\d{1,2}:\\d{1,2}$")) {
				return formarts.get(3).parse(source);
			} else if (source.matches("^\\d{4}.\\d{1,2}.\\d{1,2}$")) {
				return formarts.get(4).parse(source);
			} else {
				throw new IllegalArgumentException("Invalid boolean value '" + source + "'");
			}
		} catch (Exception e) {
			log.warn("DateUtils.formatDateStr error", e);
			return null;
		}
	}

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = (long)1000 * 24 * 60 * 60;
        long nh = (long)1000 * 60 * 60;
        long nm = (long)1000 * 60;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        return day + "天" + hour + "小时" + min + "分钟" ;
    }
    
    /**
     * 增加日期
     *
     * @param date
     * @param field  Calendar.MONTH,Calendar.DAY_OF_YEAR
     * @param amount 正数为将来时间, 负数为过去时间
     * @return
     */
    public static Date getAddDate(Date date, int field, int amount) {
        Calendar cl = Calendar.getInstance();
        cl.setTime(date);
        cl.add(field, amount);
        Date dateFrom = cl.getTime();
        return dateFrom;
    }
    
    /**
     * 获取前几周
     *
     * @param date
     * @return
     */
    public static Date getBeforeWeek(Date date, int week) {
        return getAddDate(date, Calendar.WEEK_OF_YEAR, week);
    }
 
    /**
     * 获取前几天
     *
     * @param date
     * @return
     */
    public static Date getBeforeDay(Date date, int day) {
        return getAddDate(date, Calendar.DAY_OF_YEAR, day);
    }
 
    /**
     * 获取前几月
     *
     * @param date
     * @return
     */
    public static Date getBeforeMouth(Date date, int mouth) {
        return getAddDate(date, Calendar.MONTH, mouth);
    }
 
    /**
     * 获取前几年
     *
     * @param date
     * @return
     */
    public static Date getBeforeYear(Date date, int year) {
        return getAddDate(date, Calendar.YEAR, year);
    }
 
 
    /**
     * 获取后几周
     *
     * @param date
     * @return
     */
    public static Date getAfterWeek(Date date,int week) {
        return getAddDate(date, Calendar.WEEK_OF_YEAR, week);
    }
 
    /**
     * 获取后几天
     *
     * @param date
     * @return
     */
    public static Date getAfterDay(Date date, int day) {
        return getAddDate(date, Calendar.DAY_OF_YEAR, day);
    }
 
    /**
     * 获取后几月
     *
     * @param date
     * @return
     */
    public static Date getAfterMouth(Date date, int month) {
        return getAddDate(date, Calendar.MONTH, month);
    }
 
    /**
     * 获取后几年
     *
     * @param date
     * @return
     */
    public static Date getAfterYear(Date date, int year) {
        return getAddDate(date, Calendar.YEAR, year);
    }


}

第三种：先将solrDocument类转换为json，然后再将此json转换为我要的业务对象类

/**
	 * 
	 * @Title: getCommonsHttpSolrServer @Description: HttpSolrClient
	 *         初始化 @param: @return @param: @throws
	 *         MalformedURLException @return: HttpSolrClient @throws
	 */
	protected HttpSolrServer  getHttpSolrServer(HttpServletRequest request, String solrCoreName) {
		String solruri = "http://" + request.getServerName() + ":" + request.getServerPort() + "/solr-webapp/";
		solruri = ApplicationPropertiesHolder.getProperty("request.solr.uri", solruri);
		solruri = solruri + solrCoreName + "/";
		HttpSolrServer server =new HttpSolrServer(solruri);
		server.setParser(new XMLResponseParser()); // binary parser is used by
		// 设置重试次数
    	server.setMaxRetries(2);
    	// 设置超时时间
    	server.setConnectionTimeout(5000);
		return server;
	}
	
	// 设置查询条件
	public String getQueryCondition(String text) {
			if(StringUtils.isNotEmpty(text)){
				StringBuilder builder = new StringBuilder();
				List<String> filterStr = Arrays.asList(text.split("\\s+"));
				List<String> list = filterStr.stream().map(item ->{
					return "text:" + "*".concat(item).concat("*");
				}).collect(Collectors.toList());
			
				for (int i = 0; i < list.size(); i++) {
					builder.append(list.get(i));
					if (i < list.size() - 1) {
						builder.append(" and ");
					}
				}
				return builder.toString();
			}
			return StringUtils.EMPTY;
			
		}
	
	@RequestMapping(value = "/querySolr", method = { RequestMethod.POST })
	@ResponseBody
	@ApiOperation(value = "工程档案检索")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "text", value = "检索关键字", required = true, dataType = "String", paramType = "query"),
			@ApiImplicitParam(name = "type", value = "检索类型", required = true, dataType = "String", paramType = "query"),
			@ApiImplicitParam(name = "page", value = "页码", required = false, dataType = "Integer", paramType = "query"),
			@ApiImplicitParam(name = "limit", value = "页次", required = false, dataType = "Integer", paramType = "query")
			
	})
	public Result querySolr(HttpServletRequest request,
			@RequestBody(required = false) HashMap<String, Object> entity) {
		
				String type = SimpleTypeConverterUtil.convertIfNecessary(entity.get("type"), String.class);
				entity.remove("type");
				if(StringUtils.isEmpty(type)){
					return Result.error("检索必须指定类型");
				}
				// 构建查询条件
				SolrQuery query = new SolrQuery();
				
				// 分页参数
				PageParam rb = super.initPageBounds(entity);
				query.setStart((rb.getPageNo() - 1) * rb.getLimit() > 0
						? (rb.getPageNo() - 1) * rb.getLimit() : 0);
				query.setRows(rb.getLimit());
				
				// 设置查询条件
				String condition = this.getQueryCondition(SimpleTypeConverterUtil.convertIfNecessary(entity.get("text"), String.class));
				if (StringUtils.isNotEmpty(condition)) {
					logger.error("query 条件:" + condition);
					query.setQuery(condition);
				}
		 
				// solr 查询
				QueryResponse queryResponse = null;
				try {
					HttpSolrServer httpSolrServer = this.getHttpSolrServer(request, type);
					queryResponse = httpSolrServer.query(query);
		 
				} catch (SolrServerException e) {
					// TODO Auto-generated catch block
					logger.error("solr 检索异常:{}", e.getMessage(), e);
					return Result.error("档案检索异常");
				}
		 
				// solr 查询结果分页
				
				List<SolrDocument> list = queryResponse.getResults();
				if(CollectionUtils.isEmpty(list)){
					return Result.error("档案未检索到相关数据");
				}
				PageData<Object> page = getSolrResult(rb, queryResponse, list, type);
				return Result.ok().setData(page);
			
	}

	/**
	 * 转换solr 检索结果对象
	 * @param rb
	 * @param queryResponse
	 * @param list
	 * @param type
	 * @return
	 */
	private PageData<Object> getSolrResult(PageParam rb, QueryResponse queryResponse, List<SolrDocument> list, String type) {
		List<Object> maps =  list.stream().map(item->{
				
				String json = JSON.toJSONString(item);
				if(SolrIndexEnum.ArchInfo.getIndex().equalsIgnoreCase(type)){
					return JSON.parseObject(json, ArchInfo.class);	
				} else if(SolrIndexEnum.ContractUnitInfo.getIndex().equalsIgnoreCase(type)){
					return JSON.parseObject(json, ContractUnitInfo.class);
				} else if(SolrIndexEnum.EngBaseInfo.getIndex().equalsIgnoreCase(type)){
					return JSON.parseObject(json, EngBaseInfo.class);
				} else {
					return JSON.parseObject(json, IndividualInfo.class);
				}				
		}).collect(Collectors.toList());
		
		PageData<Object> page = new PageData<Object>();
		page.setData(maps);
		page.setTotalCount(queryResponse.getResults().getNumFound() != 0 ? queryResponse.getResults().getNumFound() : 0);
		page.setPageSize(rb.getLimit());
		page.setPageNum(rb.getPageNo());
		return page;
	}

在奋斗的大道
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lucene solr框架代码实例（可直接运行）
05-15
Java搜索，lucene。 但是有时候lucene比较麻烦使用起来，所以，出现了solr。 solr只需配置一下，再写一些简单的代码，即可很好的实现lucene的功能，方便快捷。
SpringBoot集成Solr全文检索，示例工程源码，ik分词插件
03-25
在Solr的配置文件中（如`schema.xml`或`managed-schema`），需要配置IK分词器，并指定其版本，如`<fieldType name="text_ik" class="solr.TextField" positionIncrementGap="100"> <analyzer type="index"> ...
Solr使用SolrDocumentList获取数据库的数据，常见异常
默默的笔记
01-04 2461
最近初学Solr，使用SolrDocumentList获取数据库的数据，遇到了一下几个常见异常，在这里记录下来，以便日后查找 一、配置文件data-config.xml 这个文件MySql连接的配置，现在放上我此次项目的文件内容 <dataConfig> <!-- 这是mysql的配置，学会jdbc的都应该看得懂 --> <dataSource...
solr高级查询应用---按字段分组查询
yangyang_VV的博客
05-30 1294
一：solr在admin管理界面查询语句编写： 二：GROPU参数 三：Group分组时候关于 FacetLimit参数设置： 如果不设置limit的话，默认返回最大100 //只要给你的sorlquery加上这个门面限制为-1，就是不限制数量。 SolrQuery queryArgs = new SolrQuery(); queryArgs.setFacetLimit(-1); 四：java查询solr分组代码编写： package com.dss.solr.test; import java.u
Solr之查询页面，索引，SolrJ
上善若泪
04-20 1469
自动检测文件夹中的内容类型，但将其限制为 PPT 和 HTML 文件并将其索引到 gettingstarted。自动检测文件夹中的内容类型，并对其进行递归扫描，以便为编入 gettingstarted 的文档进行索引。文件是什么类型的内容。的字段类型必须是 DateField( 或其子类型 ). 需要注意的是 , 使用。）参数是需要将文件视为正确的类型，否则将被忽略，并记录一个警告，因为它不知道。工具），用于将各种类型的内容发布到 Solr 服务器。元素中的属性是随意的，这主要取决于。
Solr框架 02.Solr操作（document操作和query查询）
qq_38757863的博客
06-30 968
菜单项目Documents使用办法。
solr全文检索实现原理
02-24
Solr是一个独立的企业级搜索应用服务器，它对外提供类似于Web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过HttpGet操作提出查找请求，并得到XML/Json格式...
基于solr全文检索实现原理(详谈)
08-28
Solr全文检索实现原理主要基于Apache Solr，这是一个开源的企业级搜索应用服务器，它构建在Java的全文检索库Lucene之上。Solr提供了一个通过HTTP请求接口进行索引管理和搜索功能的方式，支持XML和JSON格式的数据交换...
SOLR检索调优
01-10
SOLR 检索调优
Solr：菜单项目 Documents 使用办法
最新发布
qq_33240556的博客
04-07 623
在Apache Solr的Admin UI中，"Documents"菜单项目提供了对索引文档的浏览、添加、删除和更新功能。
solr Document,Fields,Schema设计概况
slow is fast
01-08 177
翻译自 Apache Solr Reference Guide    solr一个最基本的设计原则是简洁， 你告诉他很多信息，然后问他一些问题，他会给你回答的一段信息，你喂给他的这部分叫做 indexing， 你问他的问题叫做 query。 一个理解solr的方法是举个例子，我们用一个美食的活页本，每一次你加一个活页到这本书中，你更新在最后面的索引，你列举菜的每个成分和页码在最后，设想一...
solr mysql原理_Solr的原理及使用
weixin_42512933的博客
01-19 450
1.Solr的简介Solr是一个独立的企业级搜索应用服务器，它对外提供类似于Web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过Http Get操作提出查找请求，并得到XML格式的返回结果。2.工作原理solr是基于Lucence开发的企业级搜索引擎技术，而lucence的原理是倒排索引。那么什么是倒排索引呢？接下来我们就介绍...
solr使用四(实际业务中结合Spring Data Solr使用,含大量实际示例代码)
特别享受思考问题的过程
05-04 779
Spring Data Solr 更多例子 详见Spring Data Solr官方文档 一、引入pom文件依赖、修改配置文件 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-...
SolrDocument与实体类转换
ldcn的博客
10-10 3763
/** * * SolrDocument与实体类转换 * * @param document * SolrDocument对象 * @param clzz * 泛型类 * @return */ public
Solr.Document源码分析
Wild__Child的博客
10-17 130
2021SC@SDUSC /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this f
Solr性能优化之merger的合并方式优化
起跑人生,追逐梦想,超越现实
02-26 552
　　现状 　　当 solr 集群采用了 merger 的合并方式后，会把各台 solr 的结果合并到最终结果并输出，如下图所示： 　　   　　　这种是非常常规的做法，我想各路大神也早明白大概的情况了，那我也不多说了 　　　集群的基本情况就是，因为收录了大量的新闻信息，某些新闻可能某一个小时间段内插入了大量数据，而某些时间段却木有，比如：“车祸“这一个关键字，在早上的9点1分1秒添加...
solr合并集合
五哥的酒馆
05-09 614
&#13;      当需要合并两个不同项目或者是多个分开配置的服务器时，你既可以使用lucene-misc里面的IndexMergeTool工具，也可以使用CoreAdminHandler。       要合并索引，必须满足如下要求： 1.两个索引必须兼容：schema需要包含相同的字段，并且字段分析方法相同。 2.必须不包含相同数据。 最好两个索引是用相同的schema...
java操作solr Document数据
Min_Monk的博客
02-17 469
继上一篇，solr启动成功后，使用java来简单操作下solr的数据，也就是solr中的Document。 首先我们创建一个core来用于测试，创建core的方式见博文 Apache solr入门中的创建core章节。 这里我们创建一个test_core用于来测试 在 managed-schema文件中添加两个简单的字段（test_id, test_name）用于测试，如下：(也可以直接在界面操...
SolrDocument转换成Bean、SolrDocumentList转换成BeanList
小楼一夜听春雨
08-18 5032
/** * 将SolrDocument转换成Bean * @param record * @param clazz * @return */ public static Object toBean(SolrDocument record, Class clazz){ Object o = null; try {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值