private RMItem readDataFromLog(int id, String key, int xId) {
synchronized (logArray) {
int indx;
if ((indx = logContains(xId)) != -1) {
Log temp = (Log) logArray.elementAt(indx);
return (RMItem) temp.get(key);
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see
* org.xmind.cathy.internal.jobs.OpenFilesJob#filterFilesToOpen(java.util
* .List, org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
protected void filterFilesToOpen(List<String> filesToOpen) {
Log opening = Log.get(Log.OPENING);
if (opening.exists()) {
String[] contents = opening.getContents();
for (String line : contents) {
if (line.startsWith("xmind:") || new File(line).exists()) { // $NON-NLS-1$
filesToOpen.add(line);
}
}
opening.delete();
}
}
public void abort(int transactionId) throws RemoteException, InvalidTransactionException {
int indx = logContains(transactionId);
Log temp;
if (indx > -1) {
temp = (Log) logArray.elementAt(indx);
} else {
System.out.println("nothing in array");
return;
}
for (Enumeration e = temp.getKeys(); e.hasMoreElements(); ) {
System.out.println("For loop");
String key = (String) (e.nextElement());
RMItem obj = temp.get(key);
if (obj.getType() == 0) {
Flight flight = (Flight) obj;
if (flight.getCount() == -1) {
System.out.println("entering count=-1 block");
removeData(transactionId, key);
} else {
System.out.println("entering other block");
writeData(transactionId, key, flight);
}
} else if (obj.getType() == 1) {
Customer cust = (Customer) obj;
if (cust.getID() == -1) {
System.out.println("entering remove data for customer");
removeData(transactionId, key);
} else {
System.out.println("entering write data for customer");
writeData(transactionId, key, obj);
}
}
}
}
/**
* 设置工具类。 用于支持设置文件<br>
* 1、支持变量，默认变量命名为 ${变量名}，变量只能识别读入行的变量，例如第6行的变量在第三行无法读取
* 2、支持分组，分组为中括号括起来的内容，中括号以下的行都为此分组的内容，无分组相当于空字符分组<br>
* 若某个key是name，加上分组后的键相当于group.name 3、注释以#开头，但是空行和不带“=”的行也会被跳过，但是建议加# 4、store方法不会保存注释内容，慎重使用
*
* @author xiaoleilu
*/
public class Setting extends HashMap<String, String> {
private static final long serialVersionUID = -477527787843971824L;
private static Logger log = Log.get();
/** 默认字符集 */
public static final String DEFAULT_CHARSET = "utf8";
/** 数组类型值默认分隔符 */
public static final String DEFAULT_DELIMITER = ",";
/** 注释符号（当有此符号在行首，表示此行为注释） */
protected static final String COMMENT_FLAG_PRE = "#";
/** 赋值分隔符（用于分隔键值对） */
protected static final String ASSIGN_FLAG = "=";
/** 分组行识别的环绕标记 */
protected static final char[] GROUP_SURROUND = {'[', ']'};
/** 变量名称的正则 */
private String reg_var = "\\$\\{(.*?)\\}";
/** 本设置对象的字符集 */
private Charset charset;
/** 是否使用变量 */
private boolean isUseVariable;
/** 设定文件的URL */
private URL settingUrl;
private LinkedList<String> groups = new LinkedList<String>();
/**
* 基本构造<br>
* 需自定义初始化配置文件<br>
*
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(Charset charset, boolean isUseVariable) {
this.charset = charset;
this.isUseVariable = isUseVariable;
}
/**
* 构造，使用相对于Class文件根目录的相对路径
*
* @param pathBaseClassLoader 相对路径（相对于当前项目的classes路径）
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(String pathBaseClassLoader, String charset, boolean isUseVariable) {
if (null == pathBaseClassLoader) {
pathBaseClassLoader = StrUtil.EMPTY;
}
final URL url = URLUtil.getURL(pathBaseClassLoader);
if (url == null) {
throw new RuntimeException(
StrUtil.format("Can not find Setting file: [{}]", pathBaseClassLoader));
}
this.init(url, charset, isUseVariable);
}
/**
* 构造
*
* @param configFile 配置文件对象
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(File configFile, String charset, boolean isUseVariable) {
if (configFile == null) {
throw new RuntimeException("Null Setting file!");
}
final URL url = URLUtil.getURL(configFile);
if (url == null) {
throw new RuntimeException(
StrUtil.format("Can not find Setting file: [{}]", configFile.getAbsolutePath()));
}
this.init(url, charset, isUseVariable);
}
/**
* 构造，相对于classes读取文件
*
* @param path 相对路径
* @param clazz 基准类
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(String path, Class<?> clazz, String charset, boolean isUseVariable) {
final URL url = URLUtil.getURL(path, clazz);
if (url == null) {
throw new RuntimeException(StrUtil.format("Can not find Setting file: [{}]", path));
}
this.init(url, charset, isUseVariable);
}
/**
* 构造
*
* @param url 设定文件的URL
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(URL url, String charset, boolean isUseVariable) {
if (url == null) {
throw new RuntimeException("Null url define!");
}
this.init(url, charset, isUseVariable);
}
/**
* 构造
*
* @param pathBaseClassLoader 相对路径（相对于当前项目的classes路径）
*/
public Setting(String pathBaseClassLoader) {
this(pathBaseClassLoader, DEFAULT_CHARSET, false);
}
/*--------------------------公有方法 start-------------------------------*/
/**
* 初始化设定文件
*
* @param settingUrl 设定文件的URL
* @param charset 字符集
* @param isUseVariable 是否使用变量
* @return 成功初始化与否
*/
public boolean init(URL settingUrl, String charset, boolean isUseVariable) {
if (settingUrl == null) {
throw new RuntimeException("Null setting url or charset define!");
}
try {
this.charset = Charset.forName(charset);
} catch (Exception e) {
log.warn(
"User custom charset [{}] parse error, use default charset: [{}]",
charset,
DEFAULT_CHARSET);
this.charset = Charset.forName(DEFAULT_CHARSET);
}
this.isUseVariable = isUseVariable;
this.settingUrl = settingUrl;
return this.load(settingUrl);
}
/**
* 加载设置文件
*
* @param settingUrl 配置文件URL
* @return 加载是否成功
*/
public synchronized boolean load(URL settingUrl) {
if (settingUrl == null) {
throw new RuntimeException("Null setting url define!");
}
log.debug("Load setting file [{}]", settingUrl.getPath());
InputStream settingStream = null;
try {
settingStream = settingUrl.openStream();
load(settingStream, isUseVariable);
} catch (IOException e) {
log.error("Load setting error!", e);
return false;
} finally {
FileUtil.close(settingStream);
}
return true;
}
/** 重新加载配置文件 */
public void reload() {
this.load(settingUrl);
}
/**
* 加载设置文件。 此方法不会关闭流对象
*
* @param settingStream 文件流
* @param isUseVariable 是否使用变量（替换配置文件值中含有的变量）
* @return 加载成功与否
* @throws IOException
*/
public boolean load(InputStream settingStream, boolean isUseVariable) throws IOException {
this.clear();
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(settingStream, charset));
// 分组
String group = null;
while (true) {
String line = reader.readLine();
if (line == null) {
break;
}
line = line.trim();
// 跳过注释行和空行
if (StrUtil.isBlank(line) || line.startsWith(COMMENT_FLAG_PRE)) {
continue;
}
// 记录分组名
if (line.charAt(0) == GROUP_SURROUND[0]
&& line.charAt(line.length() - 1) == GROUP_SURROUND[1]) {
group = line.substring(1, line.length() - 1).trim();
this.groups.add(group);
continue;
}
String[] keyValue = line.split(ASSIGN_FLAG, 2);
// 跳过不符合简直规范的行
if (keyValue.length < 2) {
continue;
}
String key = keyValue[0].trim();
if (false == StrUtil.isBlank(group)) {
key = group + StrUtil.DOT + key;
}
String value = keyValue[1].trim();
// 替换值中的所有变量变量（变量必须是此行之前定义的变量，否则无法找到）
if (isUseVariable) {
value = replaceVar(value);
}
put(key, value);
}
} finally {
FileUtil.close(reader);
}
return true;
}
/**
* 设置变量的正则<br>
* 正则只能有一个group表示变量本身，剩余为字符 例如 \$\{(name)\}表示${name}变量名为name的一个变量表示
*
* @param regex 正则
*/
public void setVarRegex(String regex) {
this.reg_var = regex;
}
/** @return 获得设定文件的路径 */
public String getSettingPath() {
return settingUrl.getPath();
}
// --------------------------------------------------------------- Get
/**
* 带有日志提示的get，如果没有定义指定的KEY，则打印debug日志
*
* @param key 键
* @return 值
*/
public String getWithLog(String key) {
return get(key, null);
}
/**
* 带有日志提示的get，如果没有定义指定的KEY，则打印debug日志
*
* @param key 键
* @return 值
*/
public String getWithLog(String key, String group) {
final String value = get(key, group);
if (value == null) {
log.debug("No key define for [{}]!", key);
}
return value;
}
/**
* 获得指定分组的键对应值
*
* @param key 键
* @param group 分组
* @return 值
*/
public String get(String key, String group) {
String keyWithGroup = key;
if (!StrUtil.isBlank(group)) {
keyWithGroup = group + "." + keyWithGroup;
}
return get(keyWithGroup);
}
// --------------------------------------------------------------- Get String
/**
* 获取字符型型属性值
*
* @param key 属性名
* @return 属性值
*/
public String getString(String key) {
return getString(key, null);
}
/**
* 获取字符型型属性值<br>
* 若获得的值为不可见字符，使用默认值
*
* @param key 属性名
* @param defaultValue 默认值
* @return 属性值
*/
public String getStringWithDefault(String key, String defaultValue) {
return getStringWithDefault(key, null, defaultValue);
}
/**
* 获取字符型型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public String getString(String key, String group) {
return get(key, group);
}
/**
* 获取字符型型属性值<br>
* 若获得的值为不可见字符，使用默认值
*
* @param key 属性名
* @param group 分组名
* @param defaultValue 默认值
* @return 属性值
*/
public String getStringWithDefault(String key, String group, String defaultValue) {
final String value = getString(key, group);
if (StrUtil.isBlank(value)) {
return defaultValue;
}
return value;
}
// --------------------------------------------------------------- Get string array
/**
* 获得数组型
*
* @param key 属性名
* @return 属性值
*/
public String[] getStrings(String key) {
return getStrings(key, null);
}
/**
* 获得数组型
*
* @param key 属性名
* @param defaultValue 默认的值
* @return 属性值
*/
public String[] getStringsWithDefault(String key, String[] defaultValue) {
String[] value = getStrings(key, null);
if (null == value) {
value = defaultValue;
}
return value;
}
/**
* 获得数组型
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public String[] getStrings(String key, String group) {
return getStrings(key, group, DEFAULT_DELIMITER);
}
/**
* 获得数组型
*
* @param key 属性名
* @param group 分组名
* @param delimiter 分隔符
* @return 属性值
*/
public String[] getStrings(String key, String group, String delimiter) {
final String value = getString(key, group);
if (StrUtil.isBlank(value)) {
return null;
}
return StrUtil.split(value, delimiter);
}
// --------------------------------------------------------------- Get int
/**
* 获取数字型型属性值
*
* @param key 属性名
* @return 属性值
*/
public Integer getInt(String key) throws NumberFormatException {
return getInt(key, null);
}
/**
* 获取数字型型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public Integer getInt(String key, String group) {
return getInt(key, group, null);
}
/**
* 获取数字型型属性值
*
* @param key 属性名
* @param group 分组名
* @param defaultValue 默认值
* @return 属性值
*/
public Integer getInt(String key, String group, Integer defaultValue) {
return Conver.toInt(get(key, group), defaultValue);
}
// --------------------------------------------------------------- Get bool
/**
* 获取波尔型属性值
*
* @param key 属性名
* @return 属性值
*/
public Boolean getBool(String key) throws NumberFormatException {
return getBool(key, null);
}
/**
* 获取波尔型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public Boolean getBool(String key, String group) {
return getBool(key, group, null);
}
/**
* 获取波尔型型属性值
*
* @param key 属性名
* @param group 分组名
* @param defaultValue 默认值
* @return 属性值
*/
public Boolean getBool(String key, String group, Boolean defaultValue) {
return Conver.toBool(get(key, group), defaultValue);
}
// --------------------------------------------------------------- Get long
/**
* 获取long类型属性值
*
* @param key 属性名
* @return 属性值
*/
public Long getLong(String key) throws NumberFormatException {
return getLong(key, null);
}
/**
* 获取long类型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public Long getLong(String key, String group) {
return getLong(key, group, null);
}
/**
* 获取long类型属性值
*
* @param key 属性名
* @param group 分组名
* @param defaultValue 默认值
* @return 属性值
*/
public Long getLong(String key, String group, Long defaultValue) {
return Conver.toLong(get(key, group), defaultValue);
}
// --------------------------------------------------------------- Get char
/**
* 获取char类型属性值
*
* @param key 属性名
* @return 属性值
*/
public Character getChar(String key) {
return getChar(key, null);
}
/**
* 获取char类型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public Character getChar(String key, String group) {
final String value = get(key, group);
if (StrUtil.isBlank(value)) {
return null;
}
return value.charAt(0);
}
// --------------------------------------------------------------- Get double
/**
* 获取double类型属性值
*
* @param key 属性名
* @return 属性值
*/
public Double getDouble(String key) {
return getDouble(key, null);
}
/**
* 获取double类型属性值
*
* @param key 属性名
* @param group 分组名
* @return 属性值
*/
public Double getDouble(String key, String group) {
return getDouble(key, group, null);
}
/**
* 获取double类型属性值
*
* @param key 属性名
* @param group 分组名
* @param defaultValue 默认值
* @return 属性值
*/
public Double getDouble(String key, String group, Double defaultValue) {
return Conver.toDouble(get(key, group), defaultValue);
}
// --------------------------------------------------------------- Set
/**
* 设置值，无给定键创建之。设置后未持久化
*
* @param key 键
* @param value 值
*/
public void setSetting(String key, Object value) {
put(key, value.toString());
}
// --------------------------------------------------------------------------------- Functions
/**
* 持久化当前设置，会覆盖掉之前的设置<br>
* 持久化会不会保留之前的分组
*
* @param absolutePath 设置文件的绝对路径
*/
public void store(String absolutePath) {
try {
FileUtil.touch(absolutePath);
OutputStream out = FileUtil.getOutputStream(absolutePath);
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, charset));
Set<java.util.Map.Entry<String, String>> entrySet = this.entrySet();
for (java.util.Map.Entry<String, String> entry : entrySet) {
writer.write(entry.getKey() + ASSIGN_FLAG + entry.getValue());
}
writer.close();
} catch (FileNotFoundException e) {
throw new RuntimeException(StrUtil.format("Can not find file [{}]!", absolutePath), e);
} catch (IOException e) {
throw new RuntimeException("Store Setting error!", e);
}
}
/**
* 存储当前设置，会覆盖掉以前的设置
*
* @param path 相对路径
* @param clazz 相对的类
*/
public void store(String path, Class<?> clazz) {
this.store(FileUtil.getAbsolutePath(path, clazz));
}
/**
* 将setting中的键值关系映射到对象中，原理是调用对象对应的set方法<br>
* 只支持基本类型的转换
*
* @param object 被调用的对象
* @throws SettingException
*/
public void toObject(String group, Object object) throws SettingException {
try {
Method[] methods = object.getClass().getMethods();
for (Method method : methods) {
String methodName = method.getName();
if (methodName.startsWith("set")) {
String field = StrUtil.getGeneralField(methodName);
Object value = get(field, group);
if (value != null) {
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length != 1) {
continue;
}
Object castedValue = Conver.parse(parameterTypes[0], value);
method.invoke(object, castedValue);
log.debug("Parse setting to object field [{}={}]", field, value);
}
}
}
} catch (Exception e) {
throw new SettingException("Parse setting to object error!", e);
}
}
/**
* 将setting中的键值关系映射到对象中，原理是调用对象对应的set方法<br>
* 只支持基本类型的转换
*
* @param object
* @throws SettingException
*/
public void toObject(Object object) throws SettingException {
toObject(null, object);
}
/** @return 获得所有分组名 */
public LinkedList<String> getGroups() {
return this.groups;
}
/*--------------------------公有方法 end-------------------------------*/
/*--------------------------Private Method start-------------------------------*/
/**
* 替换给定值中的变量标识
*
* @param value 值
* @return 替换后的字符串
*/
private String replaceVar(String value) {
// 找到所有变量标识
final Set<String> vars = ReUtil.findAll(reg_var, value, 0, new HashSet<String>());
for (String var : vars) {
// 查找变量名对应的值
String varValue = this.get(ReUtil.get(reg_var, var, 1));
if (null != varValue) {
// 替换标识
value = value.replace(var, varValue);
}
}
return value;
}
/*--------------------------Private Method end-------------------------------*/
}
protected void printLog() {
for (int i = 1; i < log.length(); i++) {
System.out.println(log.get(i).toString());
}
}
protected void assertCompacted(int startIndex, int endIndex) {
for (int i = startIndex; i <= endIndex; i++) {
assertNull(log.get(i));
}
}