需求如图:
说明:
blackListFilter要等envFilter完成后才能开始执行
statisticFilter可以和envFilter同时开始执行
ruleEngineFilter要等blackListFilter和statisticFilter都执行完之后才能开始执行
所有的xxFilter都是Filter的子类
xml配置文件filters.xml:
<?xml version="1.0" encoding="UTF-8"?>
<channels>
<channel>
<id>loginChannel</id>
<filterInfo>
<id>envFilter</id>
<clazz>com.ljn.risk.front.filter.EnvFilter</clazz>
</filterInfo>
<filterInfo>
<id>blackListFilter</id>
<clazz>com.ljn.risk.front.filter.BlacklistFilter</clazz>
<dependency>envFilter</dependency>
<returnNeeded>true</returnNeeded>
<returnOrder>1</returnOrder>
</filterInfo>
<filterInfo>
<id>statisticFilter</id>
<clazz>com.ljn.risk.front.filter.StatisticFilter</clazz>
</filterInfo>
<filterInfo>
<id>ruleEngineFilter</id>
<clazz>com.ljn.risk.front.filter.RuleEngineFilter</clazz>
<dependency>blackListFilter</dependency>
<dependency>statisticFilter</dependency>
<returnNeeded>true</returnNeeded>
<returnOrder>2</returnOrder>
</filterInfo>
</channel>
</channels>
为什么会有returnNeeded和returnOrder?
我们的架构是,在一个方法调用里,需要多线程异步执行上述Filter,其中blackListFilter可以提前返回,也就是在一定条件下,向调用方返回blackListFilter的执行结果,但仍然会执行ruleEngineFilter;否则,等待ruleEngineFilter的执行结果。
returnNeeded表示是否可以提前返回,returnOrder表示顺序(当中间有多个Filter可以提前回时,需要指定优先级)。
解析xml时用JAXB
代码:
public class FilterLoader {
private static final Logger logger = LoggerFactory.getLogger(FilterLoader.class);
//key是channelId,values是该channel下所有Filter(已实例化)
private static Map<String, List<Filter>> channelToFiltersMap;
private static Channels channels ;
static {
reload();
}
public static List<Filter> getFilters(String channelId) {
if (channelToFiltersMap == null){
reload();
}
return channelToFiltersMap.get(channelId);
}
private static void reload() {
try {
channelToFiltersMap = new HashMap<String, List<Filter>>();
//lib目录
URL url = FilterLoader.class.getResource("/");
String packageName = FilterLoader.class.getPackage().getName();
String location = FilenameUtils.concat(url.getPath(), packageName.replace(".", "/"));
String filePath = FilenameUtils.concat(location, "filters.xml");
File file = new File(filePath);
JAXBContext jaxbContext = JAXBContext.newInstance(Channels.class);
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
channels = (Channels) jaxbUnmarshaller.unmarshal(file);
instanceAll();
logger.info("load and init filter ok");
} catch (Exception e) {
logger.error("fail", e);
}
}
private static void instanceAll() throws Exception {
List<Channel> channelList = channels.getChannels();
for (Channel channel : channelList) {
channelToFiltersMap.put(channel.getId(), instanceFilters(channel));
}
}
private static List<Filter> instanceFilters(Channel channel) throws Exception {
Map<String, Filter> idToFilterMap = new HashMap<String, Filter>();
for (FilterInfo filterInfo : channel.getFilterInfos()) {
initFilter(channel.getId(), filterInfo, idToFilterMap);
}
ArrayList<Filter> list = new ArrayList<Filter>();
list.addAll(idToFilterMap.values());
return list;
}
//这里用到了递归,把已经实例化好的Filter保存在Map<String, Filter>
private static void initFilter(final String channelId, final FilterInfo filterInfo, Map<String, Filter> maps) throws Exception {
if (maps.get(filterInfo.getId()) != null) {
return;
}
Filter filter = toFilter(filterInfo);
List<String> dependencies = filterInfo.getDependencies();
if (dependencies == null || dependencies.isEmpty()) {
maps.put(filterInfo.getId(), filter);
} else {
for (String filterId : dependencies) {
FilterInfo info = findFilterInfo(channelId, filterId);
initFilter(channelId, info, maps);
filter.addDependency(maps.get(filterId));
}
maps.put(filterInfo.getId(), filter);
}
}
//根据channelId + filterId找到filters.xml里定义的FilterInfo。可以考虑保存在map里,这样查找速度就快了
private static FilterInfo findFilterInfo(String channelId, String filterId) {
List<Channel> channelList = channels.getChannels();
Channel channel = null;
for (Channel c : channelList) {
if (c.getId().equals(channelId)) {
channel = c;
break;
}
}
if (channel != null) {
List<FilterInfo> filterInfos = channel.getFilterInfos();
for (FilterInfo f : filterInfos) {
if (f.getId().equals(filterId)) {
return f;
}
}
}
return null;
}
private static Filter toFilter(FilterInfo filterInfo) throws Exception {
String filterId = filterInfo.getId();
String clazz = filterInfo.getClazz();
int returnOrder = filterInfo.getReturnOrder();
boolean returnNeeded = filterInfo.isReturnNeeded();
Filter filter = (Filter) Class.forName(clazz).newInstance();
filter.setId(filterId);
filter.setReturnOrder(returnOrder);
filter.setReturnNeeded(returnNeeded);
return filter;
}
public static void main(String[] args) {
for (Entry<String, List<Filter>> item : channelToFiltersMap.entrySet()) {
System.out.println("channelId=" + item.getKey() + ", its filters are:");
for (Filter filter : item.getValue()) {
System.out.println(filter);
}
}
//System.out.println(channelToFiltersMap);
}
}
输出:
channelId=loginChannel, its filters are:
Filter [id=ruleEngineFilter, returnNeeded=true, returnOrder=2, dependencies=[Filter [id=blackListFilter, returnNeeded=true, returnOrder=1, dependencies=[Filter [id=envFilter, returnNeeded=false, returnOrder=0, dependencies=null]]], Filter [id=statisticFilter, returnNeeded=false, returnOrder=0, dependencies=null]]]
Filter [id=statisticFilter, returnNeeded=false, returnOrder=0, dependencies=null]
Filter [id=blackListFilter, returnNeeded=true, returnOrder=1, dependencies=[Filter [id=envFilter, returnNeeded=false, returnOrder=0, dependencies=null]]]
Filter [id=envFilter, returnNeeded=false, returnOrder=0, dependencies=null]
可见,得到了如期的结果。其实,这个解析xml并实例化类的思路,跟spring是一样的。当然,spring做得更强大和全面。这里算是重新发明了轮子,也算练手吧。
上述代码用到的其他类:
@XmlRootElement(name = "channel")
@XmlAccessorType (XmlAccessType.FIELD)
public class Channel {
private String id;
@XmlElement(name = "filterInfo")
private List<FilterInfo> filterInfos;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List<FilterInfo> getFilterInfos() {
return filterInfos;
}
public void setFilterInfos(List<FilterInfo> filterInfos) {
this.filterInfos = filterInfos;
}
@Override
public String toString() {
return "Channel [id=" + id + ", filterInfos=" + filterInfos + "]";
}
}
@XmlRootElement(name = "channels")
@XmlAccessorType(XmlAccessType.FIELD)
public class Channels {
@XmlElement(name = "channel")
private List<Channel> channels;
public List<Channel> getChannels() {
return channels;
}
public void setChannels(List<Channel> channels) {
this.channels = channels;
}
@Override
public String toString() {
return "Channels [channels=" + channels + "]";
}
}
@XmlRootElement(name = "filterInfo")
@XmlAccessorType(XmlAccessType.FIELD)
public class FilterInfo {
private String id;
private String clazz;
private boolean returnNeeded;
private int returnOrder;
@XmlElement(name = "dependency")
private List<String> dependencies;
public FilterInfo(String id, boolean returnNeeded, int returnOrder) {
super();
this.id = id;
this.returnNeeded = returnNeeded;
this.returnOrder = returnOrder;
}
public FilterInfo() {
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public boolean isReturnNeeded() {
return returnNeeded;
}
public void setReturnNeeded(boolean returnNeeded) {
this.returnNeeded = returnNeeded;
}
public int getReturnOrder() {
return returnOrder;
}
public void setReturnOrder(int returnOrder) {
this.returnOrder = returnOrder;
}
public List<String> getDependencies() {
return dependencies;
}
public void setDependencies(List<String> dependencies) {
this.dependencies = dependencies;
}
@Override
public String toString() {
return "FilterInfo [id=" + id + ", clazz=" + clazz + ", returnNeeded=" + returnNeeded + ", returnOrder=" + returnOrder + ", dependencies=" + dependencies + "]";
}
}
- 大小: 6.5 KB
分享到:
相关推荐
决不重新发明轮子.docx
如何避免产品设计中的「生造方案」和「重新发明轮子」? .doc
小班科学——轮子.doc
重新发明轮子这些是我遇到的一系列面试问题的集合,我被要求重新发明轮子。
幼儿园大班教案——轮子变变变.pdf
小班主题活动设计思路了——不起的轮子.docx
tinyregex 用Javascript实现正则表达式的实验。重新发明轮子。
52020——收藏资料.4需要几个轮子0.ppt
NULL 博文链接:https://changzhiwin.iteye.com/blog/505946
不要再重复造轮子了,Hutool这款开源工具类库贼好使(csdn)————程序
thewheel-js 停止重新发明轮子。 它在这里 ;)
军刀 小型辅助框架,因此您不必担心小事并专注于代码背后的主要逻辑,而不必一遍又一遍地重新发明轮子。 有几个有用的基类和助手,如典型的保护类、序列化助手、参数解析器(例如静态主)、扩展方法的负载等等.........
造轮子的目的,不是去重复的发明轮子,而是实际的去动手制作轮子。把一些公认的算法,优秀的思想,用自己的方式表达一下,锻炼一下,让知识成为自己思想的一部分。而不总是去google去百度,xxx好还是zzz好,而是能够...
我的2cents 小而有用的工具和技术,可以节省您重新发明轮子:) 项目描述: Historytrigger:一种基于触发器的方法,用于在 cassandra 上实施历史记录或审计跟踪。
我现在知道,这听起来像是在重新发明轮子,与它的进化后代相比,这太糟糕了,但这只是一个旨在自动化移动应用安全评估的更大项目的一部分。 现在要能够使用转发器,您只需要安装mimtproxy python模块即可。 到那里...
框架的基本原理不必重新发明轮子。 框架使开发人员的工作变得更轻松,并帮助他们专注于业务逻辑,而不必担心通用的代码段。 而且由于Java并不是最简单的编程语言之一,因此框架在这里绝对是有用的工具。 在本文中,...
避免重复造轮子,开发中常用封装的工具类,包括:类型转换器,时间格式转换器,文件传输,非Controller中获取当前session的工具类,唯一id生成器,MD5加密类(封装jdk自带的md5加密方法),数字格式化的类,得到中文...
跑表 博客文章 Reinvent the Wheel: for Science 随附的游戏!
说明:网上找了一圈表达式解析引擎实现的功能都不够满足支持业务需求,于是自己造轮子实现了一个,包含了等式,不等式,逻辑运算,参数,函数的支持。功能应该能够满足所有的业务需求了,函数可自行扩展,有需要支持...