问题如下
假设我们有一个类HotelCenter，它有方法List<Hotel> getHotelList(String city)可以获得一个城市下所有酒店列表
Hotel类有如下属性String name, String address, int price, Map<String, String> properties
酒店的非name和address的属性都可以通过properties.get(key)得到
我们需要实现以下功能
根据页面传入的参数返回对应的酒店列表，参数键值对会以&分割，参数的值如果有多个，会有逗号分隔
下述任何参数都可能缺失，对应的值如果为空串，也当做该参数不存在处理
参数会分三部分组成，过滤参数、排序参数和翻页参数
过滤参数包括
city（酒店所在城市）
name（酒店名包括name的值）
address（酒店地址包括address的值）
brand（酒店品牌属于brand的值的一个）
star（酒店星级属于star的值中的一个）
price（酒店价格在price值区间范围内）
area（酒店所属区域等于area值中的一个）
排序参数包括
sort（按照sort的值进行排序，如果值是price，就按照价格进行排序，如果值是star，则按照星级进行排序）
order（值如果是asc就是升序，是desc就是降序）
排序参数缺失时，默认按照sort=price&order=asc处理
翻页参数包括
page（page的值是需要看的酒店其实索引值和终止索引值，是左闭右开，如果选择的索引没有数据，则不处理，比如一共有30个酒店，page=20-40，需要返回后10个酒店）
翻页参数缺失时，默认按照0-20处理
以下是一个请求参数的例子
city=北京&name=酒店&address=海淀黄庄&brand=7天,如家&star=3,4&price=100-200,300-500&area=中关村&sort=price&order=desc&page=100-120
问题分析
程序行为
本程序需要实现的功能有3点:
1. 过滤集合元素
2. 排序集合元素
3. 截取集合子集
为了实现上述三个三个功能, 需要先实现:
1. 读取酒店原始数据
2. 解析URL, 构造查询条件
抽象分析
实际上过滤, 排序, 获取子集三个功能的条件都来自于URL, 而不难看出URL中的条件具有一定的共通性:
1. "&" 表示"与"关系条件
2. "," 表示"或"关系条件
3. "-" 表示范围条件
按照这个约定对URL进行解析,上述URL
city=北京&name=酒店&address=海淀黄庄&brand=7天,如家&star=3,4&price=100-200,300-500&area=中关村&sort=price&order=desc&page=100-120
可转化为
(city = 北京) && (name = 酒店) && (brand = 7天 || brand = 如家) ...
我们可以将每项条件抽象为一个对象, 并对这些对象加以组合(以Or的方式, 和And的方式)
另外,当将条件抽象为对象以后,我们需要知道这些对象需要过滤的字段对应到Hotel类中的成员变量是哪个字段, 这一点可以通过反射实现
代码实现
Hotel实体
/*
* Copyright (c) 2013 Qunar.com. All Rights Reserved.
*/
package com.qunar.task3.bean;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
/**
* @author zhenwei.liu created on 2013 13-10-15 下午8:52
* @version 1.0.0
*/
public class Hotel {
private static final String CITY_KEY = "city";
private static final String BRAND_KEY = "brand";
private static final String STAR_KEY = "star";
private static final String AREA_KEY = "area";
private String name;
private String address;
private Integer price;
private Map<String, String> properties = new HashMap<String, String>();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Integer getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getCity() {
return properties.get(CITY_KEY);
}
public void setCity(String city) {
properties.put(CITY_KEY, city);
}
public String getBrand() {
return properties.get(BRAND_KEY);
}
public void setBrand(String brand) {
properties.put(BRAND_KEY, brand);
}
public String getStar() {
return properties.get(STAR_KEY);
}
public void setStar(String star) {
properties.put(STAR_KEY, star);
}
public String getArea() {
return properties.get(AREA_KEY);
}
public void setArea(String area) {
properties.put(AREA_KEY, area);
}
public String getProperty(String key) {
return properties.get(key);
}
@Override
public String toString() {
return String.format(Locale.SIMPLIFIED_CHINESE, "%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t", name, address, price, getCity(), getArea(),
getBrand(), getStar());
}
}
Range范围类
package com.qunar.task3.util;
/**
* 表示一个数值范围的类
*
* @author zhenwei.liu created on 2013 13-10-16 上午12:15
* @version 1.0.0
*/
public class Range {
private int floor;
private int ceiling;
public Range(int floor, int ceiling) {
if (floor > ceiling)
throw new IllegalArgumentException("floor must be less than or equals to ceiling");
this.floor = floor;
this.ceiling = ceiling;
}
/**
* 范围判断,左闭右开
*
* @param i
* @return
*/
public boolean inRange(int i) {
return i < ceiling && i > floor;
}
public int getFloor() {
return floor;
}
public void setFloor(int floor) {
this.floor = floor;
}
public int getCeiling() {
return ceiling;
}
public void setCeiling(int ceiling) {
this.ceiling = ceiling;
}
}
Hotel工具类
/*
* Copyright (c) 2013 Qunar.com. All Rights Reserved.
*/
package com.qunar.task3.util;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import com.qunar.task3.bean.Hotel;
/**
* Hotel工具类
*
* @author zhenwei.liu created on 2013 13-10-15 下午9:16
* @version 1.0.0
*/
public class HotelUtils {
private static final String ORDER_DESC = "desc";
private static final Map<String, Field> fieldMap = new HashMap<String, Field>();
static {
Field[] fields = Hotel.class.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
field.setAccessible(true);
fieldMap.put(field.getName(), field);
}
}
/**
* 通过成员变量名获取变量值
*
* @param filed 待获取的变量值的变量名
* @param hotel 拥有field的hotel变量
* @return 由field指定的hotel成员变量值
* @throws IllegalAccessException
*/
public static Object getFieldVal(String filed, Hotel hotel) throws IllegalAccessException {
return hotel.getProperty(filed) == null ? fieldMap.get(filed).get(hotel) : hotel.getProperty(filed);
}
/**
* 通过成员变量名获取比较器
*
* @param filed 需要比较Hotel属性
* @return 比较器
*/
public static Comparator<Hotel> getComparator(final String filed, final String order) throws IllegalAccessException {
if (fieldMap.get(filed) == null)
throw new IllegalAccessException();
return new Comparator<Hotel>() {
@Override
public int compare(Hotel o1, Hotel o2) {
int result = 0;
if (o1.getProperty(filed) != null) { // 对位于Map内的参数排序
result = o1.getProperty(filed).compareTo(o2.getProperty(filed));
} else {
// 对其余属性排序
try {
result = getFieldVal(filed, o1).toString().compareTo(getFieldVal(filed, o2).toString());
} catch (IllegalAccessException e) { // 永远不会抛出此异常
e.printStackTrace();
// ignored
}
}
return order.equals(ORDER_DESC) ? -result : result;
}
};
}
/**
* 根据list校正range范围
*
* @param collection 用于校验的集合
* @param range 等待校验的range
* @return 校验完成的range
*/
public static Range fixRange(Collection collection, Range range) {
if (range.getFloor() < 0)
range.setFloor(0);
if (range.getCeiling() > collection.size())
range.setCeiling(collection.size());
return range;
}
}
表示过滤条件的Filter接口
package com.qunar.task3.filter;
/**
* 过滤器接口
*
* @author zhenwei.liu created on 2013 13-10-15 下午11:31
* @version 1.0.0
*/
public interface Filter<T> {
/**
* 过滤方法,用于表示待过滤元素是否符合条件
*
* @param t 待过滤元素
* @return
*/
boolean apply(T t);
}
集合过滤操作以及组合Filter的实现, Filters.java
package com.qunar.task3.filter;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
/**
* 过滤器工具类
*
* @author zhenwei.liu created on 2013 13-10-15 下午11:32
* @version 1.0.0
*/
public class Filters {
/**
* 过滤方法, 使用指定过滤器过滤集合元素
*
* @param iterable 带过滤集合
* @param filter 过滤器
* @param <T> 待过滤元素类型
* @return 过滤完成后的元素集合
*/
public static <T> Iterable<T> filter(Iterable<T> iterable, Filter<T> filter) {
List<T> list = new LinkedList<T>((Collection<T>) iterable);
for (T t : iterable) {
if (!filter.apply(t))
list.remove(t);
}
return list;
}
/**
* 返回一个判断永远为true的过滤器
*
* @param <T> 待过滤元素类型
* @return 过滤器
*/
public static <T> Filter<T> alwaysTrue() {
return new Filter<T>() {
@Override
public boolean apply(T t) {
return true;
}
};
}
/**
* 返回一个判断永远为false的过滤器
*
* @param <T> 待过滤元素类型
* @return 过滤器
*/
public static <T> Filter<T> alwaysFalse() {
return new Filter<T>() {
@Override
public boolean apply(T t) {
return false;
}
};
}
/**
* 将多个过滤器组合为OrFilter
*
* @param filters 待组合过滤器数组
* @param <T> 待过滤元素类型
* @return OrFilter过滤器
*/
public static <T> Filter<T> or(Filter<T>... filters) {
return new OrFilter<T>(Arrays.asList(filters));
}
/**
* 将多个过滤器组合为AndFilter
*
* @param filters 待组合过滤器数组
* @param <T> 待过滤元素类型
* @return AndFilter过滤器
*/
public static <T> Filter<T> and(Filter<T>... filters) {
return new AndFilter<T>(Arrays.asList(filters));
}
/**
* "或"组合过滤器
*
* @param <E>
*/
private static class OrFilter<E> implements Filter<E> {
private final List<? extends Filter<? super E>> components;
/**
* 组合多个过滤器
*
* @param components 待组合过滤器集合
*/
private OrFilter(List<? extends Filter<? super E>> components) {
this.components = components;
}
/**
* 过滤方法,依次调用过滤器集合每个过滤器的过滤方法,以"或"的方式组合
*
* @param e 待过滤元素
* @return 过滤结果
*/
@Override
public boolean apply(E e) {
for (int i = 0; i < components.size(); i++) {
if (components.get(i).apply(e))
return true;
}
return false;
}
}
/**
* "与"组合过滤器
*
* @param <E>
*/
private static class AndFilter<E> implements Filter<E> {
private final List<? extends Filter<? super E>> components;
/**
* 组合多个过滤器
*
* @param components 待组合过滤器集合
*/
private AndFilter(List<? extends Filter<? super E>> components) {
this.components = components;
}
/**
* 过滤方法,依次调用过滤器集合每个过滤器的过滤方法,以"与"的方式组合
*
* @param e 待过滤元素
* @return 过滤结果
*/
@Override
public boolean apply(E e) {
for (int i = 0; i < components.size(); i++) {
if (!components.get(i).apply(e))
return false;
}
return true;
}
}
}
测试类
package com.qunar.task3;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;
import com.qunar.task3.bean.Hotel;
import com.qunar.task3.filter.Filter;
import com.qunar.task3.filter.Filters;
import com.qunar.task3.util.HotelUtils;
import com.qunar.task3.util.Range;
/**
* 酒店中心,用于处理查询参数,筛选符合条件的酒店
*
* @author zhenwei.liu created on 2013 13-10-15 下午8:53
* @version 1.0.0
*/
public class HotelCenter {
private static final Set<String> FILTER_PARAMS = new HashSet<String>();
private static final List<Hotel> HOTEL_LIST = new ArrayList<Hotel>();
private static final String SORT_KEY = "sort";
private static final String ORDER_KEY = "order";
private static final String PAGE_KEY = "page";
// 准备酒店数据
static {
FILTER_PARAMS.add("city");
FILTER_PARAMS.add("name");
FILTER_PARAMS.add("address");
FILTER_PARAMS.add("brand");
FILTER_PARAMS.add("star");
FILTER_PARAMS.add("price");
FILTER_PARAMS.add("area");
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(System.getProperty("user.dir")
+ "\\src\\main\\java\\com\\qunar\\task3\\hotels.txt"));
String s;
while ((s = br.readLine()) != null) {
Hotel hotel = new Hotel();
String[] ss = s.split("；");
hotel.setName(ss[0]);
hotel.setAddress(ss[1]);
hotel.setCity(ss[2]);
hotel.setPrice(Integer.parseInt(ss[3]));
hotel.setBrand(ss[4]);
hotel.setStar(ss[5]);
hotel.setArea(ss[6]);
HOTEL_LIST.add(hotel);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
System.out.println("Hotel info file not found");
System.exit(-1);
} catch (IOException e) {
e.printStackTrace();
System.out.println("Error occur while reading hotel info ");
System.exit(-1);
} finally {
if (br != null)
try {
br.close();
} catch (IOException e) {
// ignored
}
}
}
private List<Hotel> result;
private Range pagination;
private Comparator<Hotel> comparator;
private Filter<Hotel> filter = Filters.alwaysTrue();
private Map<String, String> paramsMap = new HashMap<String, String>();
public HotelCenter(String paramStr) {
// 参数解析,不考虑参数非法情况
String[] ss = paramStr.split("&");
for (String s : ss) {
String[] ss2 = s.split("=");
if (ss2.length == 2)
paramsMap.put(ss2[0], ss2[1]);
}
initFilter();
initComparator();
initPagination();
}
/**
* 获取包含所有过滤条件的过滤器 解析一次,无限使用
*
* @return
*/
private void initFilter() {
for (final String s : paramsMap.keySet()) {
if (FILTER_PARAMS.contains(s)) { // 仅处理过滤参数
// ","分隔的参数使用OrFilter连接
String[] ss = paramsMap.get(s).split(",");
Filter<Hotel> tmpFilter = Filters.alwaysFalse();
for (int i = 0; i < ss.length; i++) {
String s1 = ss[i];
final String[] ss1 = s1.split("-");
if (ss1.length > 1) { // 处理范围参数,使用range包装
tmpFilter = Filters.or(tmpFilter, new Filter<Hotel>() {
@Override
public boolean apply(Hotel hotel) {
try {
return new Range(Integer.valueOf(ss1[0]), Integer.valueOf(ss1[1])).inRange(Integer
.valueOf(HotelUtils.getFieldVal(s, hotel).toString()));
} catch (IllegalAccessException e) {
return true;
}
}
});
} else { // 处理单个参数
tmpFilter = Filters.or(tmpFilter, new Filter<Hotel>() {
@Override
public boolean apply(Hotel hotel) {
try {
return HotelUtils.getFieldVal(s, hotel).toString().contains(ss1[0]);
} catch (IllegalAccessException e) {
return true;
}
}
});
}
}
// "&"分隔的参数使用AndFilter连接
filter = Filters.and(filter, tmpFilter);
}
}
}
public void initComparator() {
try {
comparator = HotelUtils.getComparator(paramsMap.get(SORT_KEY), paramsMap.get(ORDER_KEY));
} catch (IllegalAccessException e) {
e.printStackTrace();
System.out.println("Illegal access field: " + paramsMap.get(SORT_KEY));
}
}
public void initPagination() {
String[] ss = paramsMap.get(PAGE_KEY).split("-");
pagination = new Range(Integer.valueOf(ss[0]), Integer.valueOf(ss[1]));
}
public Iterable<Hotel> getHotelResult() {
if (result != null)
return result;
result = new ArrayList<Hotel>((Collection<Hotel>) Filters.filter(HOTEL_LIST, filter));
Collections.sort(result, comparator);
pagination = HotelUtils.fixRange(result, pagination);
result = result.subList(pagination.getFloor(), pagination.getCeiling());
return result;
}
public static void main(String[] args) {
String params = "city=北京&sort=price&price=100-200,300-400&order=desc&page=2-8";
HotelCenter hc = new HotelCenter(params);
for (Hotel hotel : hc.getHotelResult()) {
System.out.println(hotel);
}
}
}
总结
这样抽象的好处是以后可扩展性良好, 加入了新的过滤字段条件后, 只需要修改Hotel的bean字段, 并将该字段添加到FILTER_PARAMS中即可
当然也可以使用简单暴力的多重if来过滤这些字段 :D
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
