package com.walker.infrastructure.arguments.support;
|
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
|
import com.walker.infrastructure.core.DomParser;
|
import com.walker.infrastructure.core.domx.Dom4jParser;
|
//import com.walker.infrastructure.core.domx.Jdom2Parser;
|
|
import com.walker.infrastructure.arguments.ArgumentsException;
|
import com.walker.infrastructure.arguments.Group;
|
import com.walker.infrastructure.arguments.Variable;
|
import com.walker.infrastructure.arguments.VariableType;
|
import com.walker.infrastructure.utils.StringUtils;
|
import com.walker.infrastructure.utils.WorkingTimeTester;
|
import org.dom4j.Attribute;
|
import org.dom4j.Document;
|
import org.dom4j.Element;
|
import org.dom4j.Node;
|
import org.dom4j.io.OutputFormat;
|
import org.dom4j.io.XMLWriter;
|
|
public class XmlArgumentsManager extends FileArgumentsManager {
|
|
private final DomParser<Document> domParser = new Dom4jParser();
|
// private final DomParser<Document> domParser = new Jdom2Parser();
|
|
private Document document;
|
|
private final OutputFormat format = OutputFormat.createPrettyPrint();
|
|
@SuppressWarnings("unchecked")
|
@Override
|
protected List<Group> loadFile(InputStream inputStream) throws Exception {
|
document = domParser.getDocumentFromStream(inputStream);
|
Element e = document.getRootElement();
|
if(e == null) return null;
|
|
List<Group> groupList = new ArrayList<Group>(8);
|
for(Iterator<Element> j = e.elementIterator(); j.hasNext();){
|
groupList.add(loadGroups(j.next()));
|
}
|
return groupList;
|
}
|
|
@SuppressWarnings("unchecked")
|
private Group loadGroups(Element groupElement){
|
String name = groupElement.getName().toLowerCase();
|
if(!name.equalsIgnoreCase(GROUP_NAME))
|
throw new IllegalArgumentException("unsupported group name: " + name);
|
|
DefaultGroup _group = new DefaultGroup();
|
|
Attribute attr = null;
|
for(Iterator<Attribute> a = groupElement.attributeIterator(); a.hasNext();){
|
attr = a.next();
|
if(attr.getName().equalsIgnoreCase(GROUP_ID_ATTR)){
|
_group.setId(attr.getValue().trim());
|
} else if(attr.getName().equalsIgnoreCase(GROUP_NAME_ATTR)){
|
_group.setName(attr.getValue().trim());
|
} else if(attr.getName().equalsIgnoreCase(GROUP_ORDER_ATTR)){
|
_group.setOrder(Integer.parseInt(attr.getValue().trim()));
|
}
|
}
|
|
/* 加载分组下的参数子节点 */
|
List<Variable> list = loadVariables(groupElement);
|
_group.setChildren(list);
|
logger.info("--------------------- 【开始】加载参数分组：" + name);
|
for(Variable v : list){
|
logger.info(v.toString());
|
}
|
// logger.info("--------------------- 【结束】加载参数分组：" + name);
|
return _group;
|
}
|
|
@SuppressWarnings("unchecked")
|
private List<Variable> loadVariables(Element groupElement){
|
if(groupElement.elements() != null){
|
Element varElement = null;
|
List<Variable> varList = new ArrayList<Variable>(groupElement.elements().size());
|
|
for(Iterator<Element> j = groupElement.elementIterator(); j.hasNext();){
|
varElement = j.next();
|
|
if(varElement.getName().equalsIgnoreCase(VAR_NAME)){
|
Attribute attr = null;
|
DefaultVariable variable = new DefaultVariable();
|
for(Iterator<Attribute> a = varElement.attributeIterator(); a.hasNext();){
|
attr = a.next();
|
if(attr.getName().equalsIgnoreCase(VAR_ID_ATTR)){
|
variable.setId(attr.getValue().trim());
|
} else if(attr.getName().equalsIgnoreCase(VAR_NAME_ATTR)){
|
variable.setDescription(attr.getValue().trim());
|
} else if(attr.getName().equalsIgnoreCase(VAR_TYPE_ATTR)){
|
variable.setType(VariableType.getType(attr.getValue().trim()));
|
} else if(attr.getName().equalsIgnoreCase(VAR_VALUE_ATTR)){
|
variable.setValue(attr.getValue().trim());
|
} else if(attr.getName().equalsIgnoreCase(VAR_DEFAULT_ATTR)){
|
variable.setDefaultValue(attr.getValue().trim());
|
} else
|
throw new IllegalArgumentException("unsupported variable attribute: " + attr.getName());
|
}
|
varList.add(variable);
|
|
} else
|
throw new IllegalArgumentException("unsupported variable name: " + varElement.getName());
|
}
|
return varList;
|
}
|
return null;
|
}
|
|
@Override
|
protected void saveVariable(String groupId, String variableId, Object value)
|
throws Exception {
|
updateDocument(groupId, variableId, value);
|
writeFile();
|
}
|
|
@Override
|
protected void saveVariables(List<Object[]> changedList) throws Exception {
|
for(Object[] args : changedList){
|
updateDocument(args[0].toString(), args[1].toString(), args[2]);
|
}
|
writeFile();
|
}
|
|
@Override
|
protected void insertVariables(List<Object[]> insertList) throws Exception {
|
Element root = null;
|
Group group = null;
|
Variable variable = null;
|
for(Object[] objects : insertList){
|
group = (Group)objects[0];
|
variable = (Variable)objects[1];
|
Node node = document.selectSingleNode(getGroupNodeString(group.getId()));
|
if(node == null){
|
logger.debug("group不存在，需要创建: " + group);
|
root = document.getRootElement();
|
Element groupElement = root.addElement(GROUP_NAME);
|
groupElement.addAttribute(GROUP_ID_ATTR, group.getId());
|
groupElement.addAttribute(GROUP_NAME_ATTR, group.getName());
|
groupElement.addAttribute(GROUP_ORDER_ATTR, String.valueOf(group.getOrder()));
|
node = groupElement;
|
}
|
// 处理变量
|
Node varNode = document.selectSingleNode(getVariableNodeString(group.getId(), variable.getId()));
|
if(varNode != null){
|
logger.warn("variable is exist, it can't be added: " + variable);
|
continue;
|
}
|
Element varElement = ((Element)node).addElement(VAR_NAME);
|
varElement.addAttribute(VAR_ID_ATTR, variable.getId());
|
varElement.addAttribute(VAR_NAME_ATTR, variable.getDescription());
|
varElement.addAttribute(VAR_TYPE_ATTR, variable.getType().getTypeName());
|
if(variable.getType() == VariableType.String){
|
varElement.addAttribute(VAR_VALUE_ATTR, variable.getStringValue());
|
} else if(variable.getType() == VariableType.Boolean){
|
varElement.addAttribute(VAR_VALUE_ATTR, String.valueOf(variable.getBooleanValue()));
|
} else if(variable.getType() == VariableType.Integer){
|
varElement.addAttribute(VAR_VALUE_ATTR, String.valueOf(variable.getIntegerValue()));
|
} else if(variable.getType() == VariableType.Float){
|
varElement.addAttribute(VAR_VALUE_ATTR, String.valueOf(variable.getFloatValue()));
|
} else if(variable.getType() == VariableType.Long){
|
varElement.addAttribute(VAR_VALUE_ATTR, String.valueOf(variable.getLongValue()));
|
}
|
varElement.addAttribute(VAR_DEFAULT_ATTR, variable.getDefaultValue().toString());
|
}
|
writeFile();
|
}
|
|
private String getGroupNodeString(String groupId){
|
StringBuilder path = new StringBuilder("root/");
|
path.append("group[@id='");
|
path.append(groupId);
|
path.append("']");
|
return path.toString();
|
}
|
|
private String getVariableNodeString(String groupId, String variableId){
|
StringBuilder path = new StringBuilder("root/");
|
path.append("group[@id='");
|
path.append(groupId);
|
path.append("']/variable[@id='");
|
path.append(variableId);
|
path.append("']");
|
return path.toString();
|
}
|
|
private void updateDocument(String groupId, String variableId, Object value){
|
assert (StringUtils.isNotEmpty(groupId));
|
assert (StringUtils.isNotEmpty(variableId));
|
assert (value != null);
|
|
Node node = document.selectSingleNode(getVariableNodeString(groupId, variableId));
|
if(node == null){
|
throw new RuntimeException("Node not found: " + groupId + " --> " + variableId);
|
}
|
logger.debug("node = " + node.asXML());
|
Element element = (Element)node;
|
element.addAttribute(VAR_VALUE_ATTR, value.toString());
|
}
|
|
private void writeFile(){
|
XMLWriter output = null;
|
format.setEncoding("UTF-8");
|
try {
|
//用stream字节流的形式，让编码格式设置生效
|
output = new XMLWriter(new FileOutputStream(getFilePath()), format);
|
output.write(document);
|
} catch (IOException e) {
|
e.printStackTrace();
|
throw new ArgumentsException("写入文件出现错误: " + e.getMessage(), e);
|
} finally {
|
if(output != null){
|
try {
|
output.close();
|
} catch (IOException e) {
|
}
|
}
|
}
|
}
|
|
private static final String GROUP_NAME = "group";
|
private static final String GROUP_ID_ATTR = "id";
|
private static final String GROUP_NAME_ATTR = "name";
|
private static final String GROUP_ORDER_ATTR = "order";
|
|
private static final String VAR_NAME = "variable";
|
private static final String VAR_ID_ATTR = "id";
|
private static final String VAR_NAME_ATTR = "name";
|
private static final String VAR_TYPE_ATTR = "type";
|
private static final String VAR_VALUE_ATTR = "value";
|
private static final String VAR_DEFAULT_ATTR = "default";
|
|
public String toString(){
|
return this.getFilePath();
|
}
|
|
/**
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
*/
|
public static void main(String[] args) throws Exception{
|
XmlArgumentsManager argumentManager = new XmlArgumentsManager();
|
argumentManager.setClasspathFileName("variable.xml");
|
argumentManager.setSource("test");
|
argumentManager.afterPropertiesSet();
|
System.out.println(argumentManager.getVariableList("SYSTEM.SUPERPASS"));
|
|
System.out.println("+++ 分组信息: " + argumentManager.getGroupList());
|
|
WorkingTimeTester tester = new WorkingTimeTester("var");
|
Variable var = argumentManager.getVariable("11");
|
System.out.println("--分页数：" + var.getIntegerValue());
|
tester.stop();
|
|
Object[] args1 = new Object[]{"1", "11", 88};
|
Object[] args2 = new Object[]{"2", "21", "修改过企业名称"};
|
List<Object[]> argList = new ArrayList<Object[]>();
|
argList.add(args1);
|
argList.add(args2);
|
argumentManager.persist(argList);
|
// argumentManager.persist("1", "11", 56);
|
Variable v2 = argumentManager.getVariable("21");
|
System.out.println("修改后缓存: " + v2.getStringValue());
|
|
// 添加一个节点
|
DefaultGroup group2 = new DefaultGroup();
|
group2.setId("testGroup2");
|
group2.setName("系统提醒");
|
group2.setOrder(8);
|
|
DefaultVariable v = new DefaultVariable();
|
v.setId("smtp.mail.address");
|
v.setDescription("邮件发送地址");
|
v.setType(VariableType.String);
|
v.setValue("smtp.163.com");
|
v.setDefaultValue("smtp.mymail.net");
|
|
List<Object[]> insertList = new ArrayList<Object[]>();
|
insertList.add(new Object[]{group2, v});
|
argumentManager.insert(insertList);
|
}
|
|
}
|
