cn.featherfly.conversion.parse.ParsePolity Maven / Gradle / Ivy
package cn.featherfly.conversion.parse;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import cn.featherfly.common.lang.GenericType;
import cn.featherfly.common.lang.LangUtils;
import cn.featherfly.common.lang.StringUtils;
/**
*
* 解析策略
*
*
* @author 钟冀
*/
public class ParsePolity {
/**
*/
public ParsePolity() {
}
/*
* parsers
*/
private Map parsers = new HashMap();
/**
*
* 解析传入的字符串
*
* @param 返回类型
* @param resolve 需要解析的字符串
* @param gt 需要解析完成后的目标GenericType
* @return 解析后的对象
*/
public T parse(String resolve, GenericType gt) {
String protocol = null;
if (LangUtils.isNotEmpty(resolve)) {
protocol = getProtocol(resolve);
}
if (LangUtils.isEmpty(protocol)) {
return null;
}
String content = getContent(resolve);
for (Parser parser : parsers.values()) {
if (protocol.equals(parser.getProtocol())) {
return (T) parser.parse(content, gt);
}
}
return null;
}
/**
*
* 判断传入的字符串是否可以被解析
*
* @param resolve 需要解析的字符串
* @return 是否可以解析传入字符串
*/
public boolean canParse(String resolve) {
for (String protocol : parsers.keySet()) {
if (resolve.startsWith(protocol + ":")) {
return true;
}
}
return false;
}
/**
*
* 批量注册解析器
*
* @param parsers 解析器集合
*/
public void register(Collection parsers) {
if (LangUtils.isNotEmpty(parsers)) {
for (Parser parser : parsers) {
register(parser);
}
}
}
/**
*
* 批量注册解析器
*
* @param parsers 解析器数组
*/
public void register(Parser...parsers) {
if (LangUtils.isNotEmpty(parsers)) {
for (Parser parser : parsers) {
register(parser);
}
}
}
/**
*
* 注册解析器
*
* @param parser 解析器
*/
public void register(Parser parser) {
if (parser != null) {
if (isRegister(parser)) {
throw new ParseException(
StringUtils.format("协议[#1]已经被[#2]注册"
, parser.getProtocol()
, getParser(parser.getProtocol()).getClass().getName()));
}
parsers.put(parser.getProtocol(), parser);
}
}
/**
*
* 注销协议
*
* @param protocol 解析协议
*/
public void unregister(String protocol) {
parsers.remove(protocol);
}
/**
*
* 注销解析器
*
* @param parser 解析解析器
*/
public void unregister(Parser parser) {
if (parser != null) {
parsers.remove(parser.getProtocol());
}
}
/**
*
* 返回已经注册的所有协议
*
* @return 已经注册的所有协议
*/
public Collection getProtocols() {
return new ArrayList(parsers.keySet());
}
/**
*
* 返回已经注册的所有解析器
*
* @return 已经注册的所有解析器
*/
public Collection getParsers() {
return new ArrayList(parsers.values());
}
/**
*
* 返回是否注册有传入的协议
*
* @param protocol 解析协议
* @return 是否注册协议
*/
public boolean isRegister(String protocol) {
return parsers.containsKey(protocol);
}
/**
*
* 返回是否注册有传入解析器
*
* @param parser 解析器
* @return 是否注册解析器
*/
public boolean isRegister(Parser parser) {
return isRegister(parser.getProtocol());
}
/**
*
* 返回指定协议解析器
*
* @param protocol 解析协议
* @return 解析器
*/
public Parser getParser(String protocol) {
return parsers.get(protocol);
}
// ********************************************************************
//
// ********************************************************************
// ********************************************************************
//
// ********************************************************************
/**
*
* 获取传入字符串的解析协议
*
* @param resolve 需要解析的字符串
* @return 传入字符串的解析协议
*/
protected String getProtocol(String resolve) {
if (LangUtils.isEmpty(resolve)) {
return null;
}
int index = resolve.indexOf(':');
if (index > 0) {
return resolve.substring(0, index);
}
return null;
}
/**
*
* 获取传入字符串的内容
*
* @param resolve 需要解析的字符串
* @return 传入字符串的内容
*/
protected String getContent(String resolve) {
if (LangUtils.isEmpty(resolve)) {
return null;
}
int index = resolve.indexOf(':');
if (index > 0) {
return resolve.substring(index + 1);
}
return null;
}
}