Java游戏服务器开发之二十--xml配置文件

谁践踏了优雅 2022-05-18 02:24 266阅读 0赞

Java游戏服务器开发之二十--xml配置文件 
    游戏中使用的配置文件很多 
    像游戏中的关卡，英雄等级，装备之类都是使用配置文件(xml等) 
    比如有一个装备，配置表中有一条记录，数据库只需要存储这条记录的id，具体使用的时候，只需要从xml中获取这条记录就好了。 
    这些配置表一般都是前后端一致的。 
     
    现在我们服务器要做的就是解析xml，在项目启动的时候把这些数据加载到内存中。 
    本次更新，修改的内容 
        java\\com\\lizhaoblog 
            base 
                exception 
                    XmlConfigReadException.java            把解析xml中所有的错误转成XmlConfigReadException抛出 
                util 
                    ReflectUtil.java                    反射工具类            --未使用 
                xml     
                    ConfigDataArr.java                    所有配置类的父接口 
                    ConfigDataManager.java                配置文件的管理类 
                    XmlDataLoader.java                    封装好的xml解析 
                    XmlParser.java                        xml解析基础类        --未使用 
            server\\biz\\entity\\cfg 
                CfgHero.java                            对应Hero.xml中的hero标签 
                ConfigDataArrCfgHero.java                对应Hero.xml文件 
        resources\\cfg 
            data-static-config 
                Hero.xml                                Hero的配置 
            dataConfig.xml                                所有配置数据的清单文件     
        test\\java\\com\\lizhaoblog\\base\\xml 
            ConfigDataManagerTest.java                    测试类 
        pom.xml                                            添加解析xml的包 
     
    挑几个逻辑上的内容说下 
        ConfigDataArr 
            里面封装了一个方法getList 
            因为我们的数据都是以数组的形式出来的，所以都会有一个数组类和具体类，这个就是数组类的通用接口 
        ConfigDataManager 
            这里面有一个map用来存放配置文件， 
            还有个loadXml方法用于加载配置 
                通过调用XmlDataLoader.load方法 
        XmlDataLoader 
            这里面写了加载配置的整个过程，如下 
               \* 假设我在resources/cfg目录中的dataConfig.xml列出了这个项目所有的配置数据 
                    \* ---文件的格式是, 
                       \* <config> 
                       \* <file name="Hero" /> 
                       \* <file name="BBBBB" /> 
                       \* </config> 
               \* /config/file标签对应的类名为name标签---》resources/cfg目录的data-static-config目录下有标签对应的xml 
                   \* ---文件的格式是,会是一个数组，内部是Hero数据 
                       \* <Root> 
                       \* <Hero id="1" roleId="1001" name="曹操" type="1" countryType="1" icon="ui://rgylkpibej3p9" /> 
                       \* <Hero id="2" roleId="1002" name="刘备" type="2" countryType="2" icon="ui://rgylkpibej3p8" /> 
                       \* <Hero id="3" roleId="1003" name="孙权" type="3" countryType="3" icon="ui://rgylkpibej3p5" /> 
                       \* </Root> 
                        
               \* 这个xml对应的类在com.lizhaoblog.server.biz.entity.cfg.中，因为是一个数组，所以我们是需要一个数组类来接收 
               \* 前缀就是ConfigDataArrCfg 
                
               \* 在上述的流程中依次出现的是 
               \* String catalogDir = "/cfg/"; 
               \* String catalogFile = "dataConfig.xml"; 
               \* String catalogMainNode = "/config/file"; 
               \* String catalogAttribute = "name"; 
               \* String xmlFileDir = "/cfg/data-static-config/"; 
               \* String cfgPackageName = "com.lizhaoblog.server.biz.entity.cfg."; 
               \* String cfgPrefix = "ConfigDataArrCfg"; 
        ConfigDataManagerTest 
            当我们使用的时候就很简单了 
                ConfigDataManager.getInstance() 
                        .loadXml(cfgPackageName, cfgPrefix, catalogDir, catalogFile, catalogMainNode, catalogAttribute, xmlFileDir); 
                Map<String, List<?>> configDataMap = ConfigDataManager.getInstance().getConfigDataMap(); 
         
         
    把代码贴出来 
         
        pom.xml                                            添加解析xml的包

<dependency>
 <groupId>dom4j</groupId>
 <artifactId>dom4j</artifactId>
 <version>1.6.1</version>
 </dependency>
 
 <dependency>
 <groupId>com.thoughtworks.xstream</groupId>
 <artifactId>xstream</artifactId>
 <version>1.4.3</version>
 </dependency>
 
 
 
 <dependency>
 <groupId>jaxen</groupId>
 <artifactId>jaxen</artifactId>
 <version>1.1.6</version>
 </dependency>

XmlConfigReadException.java            把解析xml中所有的错误转成XmlConfigReadException抛出

/*
 * Copyright (C), 2015-2018
 * FileName: XmlConfigReadException
 * Author: zhao
 * Date: 2018/7/24 16:15
 * Description: 读取配置文件时出现错误
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.exception;
 
 /**
 * 〈一句话功能简述〉 
 * 〈读取配置文件时出现错误〉
 *
 * @author zhao
 * @date 2018/7/24 16:15
 * @since 1.0.1
 */
 public class XmlConfigReadException extends Exception {
 private String errMsg;
 
 public XmlConfigReadException(String errMsg) {
 super(errMsg);
 this.errMsg = errMsg;
 }
 
 public XmlConfigReadException(Throwable cause) {
 super(cause);
 }
 
 }

ReflectUtil.java                    反射工具类            --未使用

/*
 * Copyright (C), 2015-2018
 * FileName: ReflectUtil
 * Author: zhao
 * Date: 2018/7/24 16:07
 * Description: 反射工具类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.util;
 
 import java.lang.reflect.Field;
 import java.sql.Timestamp;
 
 /**
 * 〈一句话功能简述〉 
 * 〈反射工具类〉
 *
 * @author zhao
 * @date 2018/7/24 16:07
 * @since 1.0.1
 */
 public class ReflectUtil {
 /**
 * 将obj对象的field属性设置值为value
 *
 * @param obj 对象
 * @param field 属性
 * @param value 值
 * @throws IllegalArgumentException 非法参数异常
 * @throws IllegalAccessException 安全权限异常,一般来说,是由于java在反射时调用了private方法所导致
 */
 private static void setField(Object obj, Field field, String value) throws IllegalArgumentException, IllegalAccessException {
 field.setAccessible(true);
 if (field.getType() == int.class) {
 field.setInt(obj, Integer.parseInt(value));
 } else if (field.getType() == short.class) {
 field.setShort(obj, Short.parseShort(value));
 } else if (field.getType() == byte.class) {
 field.setByte(obj, Byte.parseByte(value));
 } else if (field.getType() == long.class) {
 field.setLong(obj, Long.parseLong(value));
 } else if (field.getType() == double.class) {
 field.setDouble(obj, Double.parseDouble(value));
 } else if (field.getType() == float.class) {
 field.setFloat(obj, Float.parseFloat(value));
 } else if (field.getType() == Timestamp.class) {
 field.set(obj, Timestamp.valueOf(value));
 } else {
 field.set(obj, field.getType().cast(value));
 }
 }
 
 }

ConfigDataArr.java                    所有配置类的父接口

/*
 * Copyright (C), 2015-2018
 * FileName: ConfigDataArr
 * Author: zhao
 * Date: 2018/7/24 15:09
 * Description: 配置数据数组的基类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.xml;
 
 import java.util.List;
 
 /**
 * 〈一句话功能简述〉 
 * 〈配置数据数组的基类〉
 *
 * @author zhao
 * @date 2018/7/24 15:09
 * @since 1.0.1
 */
 public interface ConfigDataArr {
 /**
 * 配置数据存有一个数组，该方法将返回这个数组
 *
 * @return 返回数组
 */
 List getList();
 }

ConfigDataManager.java                配置文件的管理类

/*
 * Copyright (C), 2015-2018
 * FileName: ConfigDataManager
 * Author: zhao
 * Date: 2018/7/24 15:12
 * Description: 配置数据的管理类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.xml;
 
 import com.lizhaoblog.base.exception.XmlConfigReadException;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
 * 〈一句话功能简述〉 
 * 〈配置数据的管理类〉
 *
 * @author zhao
 * @date 2018/7/24 15:12
 * @since 1.0.1
 */
 public class ConfigDataManager {
 private static ConfigDataManager instance = null;
 /**
 * key:实体名 value:该实体下的所有模板数据
 */
 private Map<String, List<?>> configDataMap;
 
 private ConfigDataManager() {
 configDataMap = new HashMap<String, List<?>>();
 }
 
 public static ConfigDataManager getInstance() {
 if (instance == null) {
 instance = new ConfigDataManager();
 }
 return instance;
 }
 
 /**
 * 假设我在resources/cfg目录中的dataConfig.xml列出了这个项目所有的配置数据
 * ---文件的格式是,
 * <config>
 * <file name="Hero" />
 * <file name="BBBBB" />
 * </config>
 * /config/file标签对应的类名为name标签---》resources/cfg目录的data-static-config目录下有标签对应的xml
 * ---文件的格式是,会是一个数组，内部是Hero数据
 * <Root>
 * <Hero id="1" roleId="1001" name="曹操" type="1" countryType="1" icon="ui://rgylkpibej3p9" />
 * <Hero id="2" roleId="1002" name="刘备" type="2" countryType="2" icon="ui://rgylkpibej3p8" />
 * <Hero id="3" roleId="1003" name="孙权" type="3" countryType="3" icon="ui://rgylkpibej3p5" />
 * </Root>
 * 
 * 这个xml对应的类在com.lizhaoblog.server.biz.entity.cfg.中，因为是一个数组，所以我们是需要一个数组类来接收
 * 前缀就是ConfigDataArrCfg
 * 
 * 在上述的流程中依次出现的是
 * String catalogDir = "/cfg/";
 * String catalogFile = "dataConfig.xml";
 * String catalogMainNode = "/config/file";
 * String catalogAttribute = "name";
 * String xmlFileDir = "/cfg/data-static-config/";
 * String cfgPackageName = "com.lizhaoblog.server.biz.entity.cfg.";
 * String cfgPrefix = "ConfigDataArrCfg";
 *
 * @param cfgPackageName 转换出来的类所在的包名
 * @param cfgPrefix 转换出来类的前缀
 * @param catalogDir 所有配置的清单文件 所在的文件夹
 * @param catalogFile 所有配置的清单文件
 * @param catalogMainNode 清单文件的标签
 * @param catalogAttribute 清单文件的标签名称
 * @param xmlFileDir xml文件对应的路径
 */
 public void loadXml(String cfgPackageName, String cfgPrefix, String catalogDir, String catalogFile,
 String catalogMainNode, String catalogAttribute, String xmlFileDir) throws XmlConfigReadException {
 XmlDataLoader dl = new XmlDataLoader(cfgPackageName, cfgPrefix, catalogDir, catalogFile, catalogMainNode,
 catalogAttribute, xmlFileDir);
 dl.load();
 }
 
 /**
 * 获取该实体类下所有模板数据
 *
 * @param beanName 实体类
 * @return 实体类对应的所有模板数据
 */
 @SuppressWarnings("unchecked")
 public List listAll(String beanName) {
 return configDataMap.get(beanName);
 }
 
 /**
 * 注册对象到对应类的List中
 *
 * @param key key
 * @param dataMap 数据map
 */
 public void registerObject(Object key, Map<String, List<?>> dataMap) {
 add(key.getClass().getSimpleName(), key, dataMap);
 }
 
 @SuppressWarnings("unchecked")
 private void add(String key, Object data, Map<String, List<?>> dataMap) {
 List list = dataMap.computeIfAbsent(key, k -> new ArrayList());
 list.add(data);
 }
 
 public Map<String, List<?>> getConfigDataMap() {
 return configDataMap;
 }
 
 public void setConfigDataMap(Map<String, List<?>> configDataMap) {
 this.configDataMap = configDataMap;
 }
 
 public void afterLoad() {
 // 加载后处理
 }
 
 public void loadCanShu() {
 // 加载全局参数xml配置
 }
 }

XmlDataLoader.java                    封装好的xml解析

/*
 * Copyright (C), 2015-2018
 * FileName: XmlDataLoader
 * Author: zhao
 * Date: 2018/7/24 12:14
 * Description: 加载配置文件获取到实际的配置类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.xml;
 
 import com.lizhaoblog.base.exception.XmlConfigReadException;
 
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.Element;
 import org.dom4j.io.SAXReader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
 
 /**
 * 〈一句话功能简述〉 
 * 〈加载配置文件获取到实际的配置类〉
 *
 * @author zhao
 * @date 2018/7/24 12:14
 * @since 1.0.1
 */
 public class XmlDataLoader {
 private static final Logger logger = LoggerFactory.getLogger(XmlDataLoader.class);
 
 /**
 * 业务中对应配置文件的包名全路径
 */
 private String cfgPackageName;
 /**
 * 对应配置文件的各个类的前缀
 */
 private String cfgPrefix;
 /**
 * 所有配置的清单文件 所在的文件夹
 */
 private String catalogDir;
 /**
 * 所有配置的清单文件
 */
 private String catalogFile;
 /**
 * 清单文件的标签
 */
 private String catalogMainNode;
 /**
 * 清单文件的标签名称
 */
 private String catalogAttribute;
 
 /**
 * xml文件对应的路径
 */
 private String xmlFileDir;
 
 private static final String POSTFIX_XML = ".xml";
 
 // public XmlDataLoader(String packageName, String catalogFile) {
 // this.cfgPackageName = packageName;
 // this.catalogFile = catalogFile;
 // }
 
 /**
 * 假设我在resources/cfg目录中的dataConfig.xml列出了这个项目所有的配置数据
 * ---文件的格式是,
 * <config>
 * <file name="Hero" />
 * <file name="BBBBB" />
 * </config>
 * /config/file标签对应的类名为name标签---》resources/cfg目录的data-static-config目录下有标签对应的xml
 * ---文件的格式是,会是一个数组，内部是Hero数据
 * <Root>
 * <Hero id="1" roleId="1001" name="曹操" type="1" countryType="1" icon="ui://rgylkpibej3p9" />
 * <Hero id="2" roleId="1002" name="刘备" type="2" countryType="2" icon="ui://rgylkpibej3p8" />
 * <Hero id="3" roleId="1003" name="孙权" type="3" countryType="3" icon="ui://rgylkpibej3p5" />
 * </Root>
 * 
 * 这个xml对应的类在com.lizhaoblog.server.biz.entity.cfg.中，因为是一个数组，所以我们是需要一个数组类来接收
 * 前缀就是ConfigDataArrCfg
 * 
 * 在上述的流程中依次出现的是
 * String catalogDir = "/cfg/";
 * String catalogFile = "dataConfig.xml";
 * String catalogMainNode = "/config/file";
 * String catalogAttribute = "name";
 * String xmlFileDir = "/cfg/data-static-config/";
 * String cfgPackageName = "com.lizhaoblog.server.biz.entity.cfg.";
 * String cfgPrefix = "ConfigDataArrCfg";
 *
 * @param cfgPackageName 转换出来的类所在的包名
 * @param cfgPrefix 转换出来类的前缀
 * @param catalogDir 所有配置的清单文件 所在的文件夹
 * @param catalogFile 所有配置的清单文件
 * @param catalogMainNode 清单文件的标签
 * @param catalogAttribute 清单文件的标签名称
 * @param xmlFileDir xml文件对应的路径
 */
 public XmlDataLoader(String cfgPackageName, String cfgPrefix, String catalogDir, String catalogFile,
 String catalogMainNode, String catalogAttribute, String xmlFileDir) {
 this.cfgPackageName = cfgPackageName;
 this.cfgPrefix = cfgPrefix;
 this.catalogDir = catalogDir;
 this.catalogFile = catalogFile;
 this.catalogMainNode = catalogMainNode;
 this.catalogAttribute = catalogAttribute;
 this.xmlFileDir = xmlFileDir;
 }
 
 /**
 * 调用load方法加载所有的配置文件
 *
 * @throws XmlConfigReadException 加载配置文件时出现的错误
 */
 public void load() throws XmlConfigReadException {
 SAXReader reader = new SAXReader();
 try {
 InputStream resourceAsStream = getClass().getResourceAsStream(catalogDir + catalogFile);
 InputStreamReader inputStreamReader = new InputStreamReader(resourceAsStream);
 Document doc = reader.read(inputStreamReader);
 List<?> nodes = doc.selectNodes(catalogMainNode);
 Map<String, List<?>> dataMap = new HashMap<String, List<?>>();
 List<String> files = new LinkedList<String>();
 for (Object n : nodes) {
 Element t = (Element) n;
 String f = t.attributeValue(catalogAttribute);
 ConfigDataArr ob = (ConfigDataArr) loadFile(f);
 for (Object o : ob.getList()) {
 ConfigDataManager.getInstance().registerObject(o, dataMap);
 }
 files.add(f);
 }
 logger.info("读取配置完毕，准备afterLoad");
 ConfigDataManager.getInstance().setConfigDataMap(dataMap);
 ConfigDataManager.getInstance().afterLoad();
 logger.info("afterLoad 完毕");
 } catch (DocumentException e) {
 throw new XmlConfigReadException("载入文件出错：DocumentException " + e.getMessage());
 }
 }
 
 private Object loadFile(String className) throws XmlConfigReadException {
 
 InputStream resourceAsStream = null;
 try {
 String file = xmlFileDir + className + POSTFIX_XML;
 logger.info("load file: {}", file);
 resourceAsStream = getClass().getResourceAsStream(file);
 if (resourceAsStream == null) {
 throw new XmlConfigReadException("文件不存在:" + file);
 }
 return loadFromStream(className, resourceAsStream);
 } finally {
 try {
 if (resourceAsStream != null) {
 resourceAsStream.close();
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 }
 
 public Object loadFromStream(String name, InputStream resourceAsStream) throws XmlConfigReadException {
 // get clazz
 String className = cfgPackageName + cfgPrefix + name;
 try {
 Class<?> classObject = Class.forName(className);
 if (classObject == null) {
 logger.error("未找到类" + className);
 return Collections.EMPTY_LIST;
 }
 JAXBContext context = JAXBContext.newInstance(classObject);
 Unmarshaller unmarshaller = context.createUnmarshaller();
 return unmarshaller.unmarshal(resourceAsStream);
 } catch (JAXBException | ClassNotFoundException e) {
 throw new XmlConfigReadException("loadFromStream 出现错误：" + name + " " + e.getClass() + " " + e.getMessage());
 }
 }
 
 }

XmlParser.java                        xml解析基础类        --未使用

/*
 * Copyright (C), 2015-2018
 * FileName: XmlParser
 * Author: zhao
 * Date: 2018/7/24 11:55
 * Description: xml的解析类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.xml;
 
 import org.dom4j.Attribute;
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.DocumentHelper;
 import org.dom4j.Element;
 import org.dom4j.Node;
 import org.dom4j.io.OutputFormat;
 import org.dom4j.io.SAXReader;
 import org.dom4j.io.XMLWriter;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 /**
 * 〈一句话功能简述〉 
 * 〈xml的解析类〉
 *
 * @author zhao
 * @date 2018/7/24 11:55
 * @since 1.0.1
 */
 public class XmlParser {
 private XmlParser() {
 }
 
 /**
 * @param xmlPath
 * 方法功能描述：生成空的xml文件头
 * 方法名:createEmptyXmlFile
 * 返回类型：Document
 * 时间：2011-4-14下午12:44:20
 */
 public static Document createEmptyXmlFile(String xmlPath) {
 if (xmlPath == null || "".equals(xmlPath)) {
 return null;
 }
 
 XMLWriter output;
 Document document = DocumentHelper.createDocument();
 
 OutputFormat format = OutputFormat.createPrettyPrint();
 try {
 output = new XMLWriter(new FileWriter(xmlPath), format);
 output.write(document);
 output.close();
 } catch (IOException e) {
 return null;
 }
 return document;
 }
 
 /**
 * 根据xml文件路径取得document对象
 *
 * @param xmlPath
 * @return
 * @throws DocumentException
 */
 public static Document getDocument(String xmlPath) {
 if (xmlPath == null || "".equals(xmlPath)) {
 return null;
 }
 
 File file = new File(xmlPath);
 if (!file.exists()) {
 return createEmptyXmlFile(xmlPath);
 }
 
 SAXReader reader = new SAXReader();
 Document document = null;
 try {
 document = reader.read(xmlPath);
 } catch (DocumentException e) {
 e.printStackTrace();
 }
 return document;
 }
 
 /**
 * @param document DOC对象
 * 方法功能描述：得到根节点
 * 方法名:getRootEleme
 * 返回类型：Element
 * 时间：2011-4-8下午12:54:02
 */
 public static Element getRootNode(Document document) {
 if (document == null) {
 return null;
 }
 
 Element root = document.getRootElement();
 return root;
 }
 
 /**
 * @param xmlPath
 * @return
 * @throws DocumentException
 * 方法功能描述: 根据路径直接拿到根节点
 * 方法名:getRootElement
 * 参数描述 :
 * 返回类型：Element
 * 时间：2011-4-14下午03:01:14
 */
 public static Element getRootNode(String xmlPath) {
 if (xmlPath == null || "".equals(xmlPath.trim())) {
 return null;
 }
 Document document = getDocument(xmlPath);
 if (document == null) {
 return null;
 }
 return getRootNode(document);
 }
 
 /**
 * @param parent
 * 方法功能描述:得到指定元素的迭代器
 * 方法名:getIterator
 * 返回类型：Iterator<Element>
 * 时间：2011-4-14上午11:29:18
 */
 @SuppressWarnings("unchecked")
 public static Iterator<Element> getIterator(Element parent) {
 if (parent == null) {
 return null;
 }
 Iterator<Element> iterator = parent.elementIterator();
 return iterator;
 }
 
 /**
 * @param parent
 * @param childName
 * 方法功能描述: 根据子节点名称得到指定的子节点
 * 方法名:getChildElement
 * 返回类型：Element
 * 时间：2011-4-14上午11:18:03
 */
 @SuppressWarnings("unchecked")
 public static List<Element> getChildElements(Element parent, String childName) {
 childName = childName.trim();
 if (parent == null) {
 return null;
 }
 childName += "//";
 List<Element> childElements = parent.selectNodes(childName);
 return childElements;
 }
 
 /**
 * @param node
 * @return 参数描述 :
 * 方法功能描述：获取子list
 * 方法名:getChildList
 * 返回类型：List<Element>
 * 时间：2011-4-14下午12:21:52
 */
 public static List<Element> getChildList(Element node) {
 if (node == null) {
 return null;
 }
 Iterator<Element> itr = getIterator(node);
 if (itr == null) {
 return null;
 }
 List<Element> childList = new ArrayList<Element>();
 while (itr.hasNext()) {
 Element kidElement = itr.next();
 if (kidElement != null) {
 childList.add(kidElement);
 }
 }
 return childList;
 }
 
 /**
 * @param parent
 * @param nodeNodeName
 * @return 参数描述 : 父节点，子节点名称
 * 方法功能描述 : 查询没有子节点的节点，使用xpath方式
 * 方法名:getSingleNode
 * 返回类型：Node
 * 时间：2011-4-14下午12:38:25
 */
 public static Node getSingleNode(Element parent, String nodeNodeName) {
 nodeNodeName = nodeNodeName.trim();
 String xpath = "//";
 if (parent == null) {
 return null;
 }
 if (nodeNodeName == null || "".equals(nodeNodeName)) {
 return null;
 }
 xpath += nodeNodeName;
 Node kid = parent.selectSingleNode(xpath);
 return kid;
 }
 
 /**
 * @param parent
 * @param childName
 * @return 参数描述 :
 * 方法功能描述：得到子节点，不使用xpath
 * 方法名:getChild
 * 返回类型：Element
 * 时间：2011-4-14下午12:53:22
 */
 @SuppressWarnings("rawtypes")
 public static Element getChild(Element parent, String childName) {
 childName = childName.trim();
 if (parent == null) {
 return null;
 }
 if (childName == null || "".equals(childName)) {
 return null;
 }
 Element e = null;
 Iterator it = getIterator(parent);
 while (it != null && it.hasNext()) {
 Element k = (Element) it.next();
 if (k == null) {
 continue;
 }
 if (k.getName().equalsIgnoreCase(childName)) {
 e = k;
 break;
 }
 }
 return e;
 }
 
 /**
 * @param e
 * 方法功能描述：判断节点是否还有子节点
 * 方法名:hasChild
 * 返回类型：boolean
 * 时间：2011-4-14下午01:43:48
 */
 public static boolean hasChild(Element e) {
 if (e == null) {
 return false;
 }
 return e.hasContent();
 }
 
 /**
 * @param e
 * 方法功能描述：得到指定节点的属性的迭代器
 * 方法名:getAttrIterator
 * 返回类型：Iterator<Attribute>
 * 时间：2011-4-14下午01:42:38
 */
 @SuppressWarnings("unchecked")
 public static Iterator<Attribute> getAttrIterator(Element e) {
 if (e == null) {
 return null;
 }
 Iterator<Attribute> attrIterator = e.attributeIterator();
 return attrIterator;
 }
 
 /**
 * @param e
 * @return 节点属性的list集合
 * 方法功能描述：遍历指定节点的所有属性
 * 方法名:getAttributeList
 * 返回类型：List<Attribute>
 * 时间：2011-4-14下午01:41:38
 */
 public static List<Attribute> getAttributeList(Element e) {
 if (e == null) {
 return null;
 }
 List<Attribute> attributeList = new ArrayList<Attribute>();
 Iterator<Attribute> atrIterator = getAttrIterator(e);
 if (atrIterator == null) {
 return null;
 }
 while (atrIterator.hasNext()) {
 Attribute attribute = atrIterator.next();
 attributeList.add(attribute);
 }
 return attributeList;
 }
 
 /**
 * @param element 指定的元素
 * @param attrName 属性名称
 * @return Attribute
 * 方法功能描述： 得到指定节点的指定属性
 * 方法名:getAttribute
 * 返回类型：Attribute
 * 时间：2011-4-14下午01:45:27
 */
 public static Attribute getAttribute(Element element, String attrName) {
 attrName = attrName.trim();
 if (element == null) {
 return null;
 }
 if (attrName == null || "".equals(attrName)) {
 return null;
 }
 Attribute attribute = element.attribute(attrName);
 return attribute;
 }
 
 /**
 * @param e
 * @param attrName
 * 方法功能描述:获取指定节点指定属性的值
 * 方法名:attrValue
 * 返回类型：String
 * 时间：2011-4-14下午02:36:48
 */
 public static String attrValue(Element e, String attrName) {
 attrName = attrName.trim();
 if (e == null) {
 return null;
 }
 if (attrName == null || "".equals(attrName)) {
 return null;
 }
 return e.attributeValue(attrName);
 }
 
 /**
 * @return 属性集合
 * 方法功能描述：得到指定节点的所有属性及属性值
 * 方法名:getNodeAttrMap
 * 返回类型：Map<String,String>
 * 时间：2011-4-15上午10:00:26
 */
 public static Map<String, String> getNodeAttrMap(Element e) {
 Map<String, String> attrMap = new HashMap<String, String>();
 if (e == null) {
 return null;
 }
 List<Attribute> attributes = getAttributeList(e);
 if (attributes == null) {
 return null;
 }
 for (Attribute attribute : attributes) {
 String attrValueString = attrValue(e, attribute.getName());
 attrMap.put(attribute.getName(), attrValueString);
 }
 return attrMap;
 }
 
 /**
 * @param e
 * @return 参数描述 :
 * 方法功能描述: 遍历指定节点的下没有子节点的元素的text值
 * 方法名:getSingleNodeText
 * 返回类型：Map<String,String>
 * 时间：2011-4-15下午12:24:38
 */
 public static Map<String, String> getSingleNodeText(Element e) {
 Map<String, String> map = new HashMap<String, String>();
 if (e == null) {
 return null;
 }
 List<Element> kids = getChildList(e);
 for (Element e2 : kids) {
 if (e2.getTextTrim() != null) {
 map.put(e2.getName(), e2.getTextTrim());
 }
 }
 return map;
 }
 
 /**
 * @param xmlFilePath
 * @return 参数描述 :
 * 方法功能描述：遍历根节点下，没有子节点的元素节点，并将此节点的text值放入map中返回
 * 方法名:getSingleNodeText
 * 返回类型：Map<String,String>
 * 时间：2011-4-15下午12:23:30
 */
 public static Map<String, String> getSingleNodeText(String xmlFilePath) {
 xmlFilePath = xmlFilePath.trim();
 if (xmlFilePath == null || "".equals(xmlFilePath)) {
 return null;
 }
 Element rootElement = getRootNode(xmlFilePath);
 if (rootElement == null || !hasChild(rootElement)) {
 return null;
 }
 return getSingleNodeText(rootElement);
 }
 
 public enum Flag {
 //节点个数 一个
 one, //节点个数 多个
 more
 }
 
 /**
 * @param xmlFilePath
 * @param tagName
 * @param flag : 指定元素的个数
 * 方法功能描述:根据xml路径和指定的节点的名称，得到指定节点,从根节点开始找
 * 方法名:getNameNode
 * 返回类型：Element 指定的节点
 * 时间：2011-4-15下午12:22:35
 */
 @SuppressWarnings("unchecked")
 public static <T> T getNameNode(String xmlFilePath, String tagName, Flag flag) {
 xmlFilePath = xmlFilePath.trim();
 tagName = tagName.trim();
 if (xmlFilePath == null || tagName == null || "".equals(xmlFilePath) || "".equals(tagName)) {
 return null;
 }
 Element rootElement = getRootNode(xmlFilePath);
 if (rootElement == null) {
 return null;
 }
 List<Element> tagElementList = getNameElement(rootElement, tagName);
 if (tagElementList == null) {
 return null;
 }
 switch (flag) {
 case one:
 return (T) tagElementList.get(0);
 default:
 break;
 }
 return (T) tagElementList;
 }
 
 /**
 * @param parent
 * @return 参数描述 :
 * 方法功能描述:得到指定节点下所有子节点的属性集合
 * 方法名:getNameNodeAllAttributeMap
 * 返回类型：Map<Integer,Object>
 * 时间：2011-4-18下午04:40:14
 */
 public static Map<Integer, Object> getNameNodeAllKidsAttributeMap(Element parent) {
 Map<Integer, Object> allAttrMap = new HashMap<Integer, Object>();
 if (parent == null) {
 return null;
 }
 List<Element> childlElements = getChildList(parent);
 if (childlElements == null) {
 return null;
 }
 for (int i = 0; i < childlElements.size(); i++) {
 Element childElement = childlElements.get(i);
 Map<String, String> attrMap = getNodeAttrMap(childElement);
 allAttrMap.put(i, attrMap);
 }
 return allAttrMap;
 }
 
 /**
 * @param xmlFilePath xml文件名路径
 * @param nodeName 指定的节点名称
 * @return 参数描述 :
 * 方法功能描述:根据xml文件名路径和指定的节点名称得到指定节点所有子节点的所有属性集合
 * 方法名:getNameNodeAllAttributeMap
 * 返回类型：Map<Integer,Object>
 * 时间：2011-4-18下午04:51:46
 */
 @SuppressWarnings("unchecked")
 public static <T> T getNameNodeAllAttributeMap(String xmlFilePath, String nodeName, Flag flag) {
 nodeName = nodeName.trim();
 Map<String, String> allAttrMap = null;
 Map<Integer, Map<String, String>> mostKidsAllAttriMap = new HashMap<Integer, Map<String, String>>();
 if (xmlFilePath == null || nodeName == null || "".equals(xmlFilePath) || "".equals(nodeName)) {
 return null;
 }
 switch (flag) {
 case one:
 Element nameNode = getNameNode(xmlFilePath, nodeName, Flag.one);
 allAttrMap = getNodeAttrMap(nameNode);
 return (T) allAttrMap;
 case more:
 List<Element> nameKidsElements = getNameNode(xmlFilePath, nodeName, Flag.more);
 for (int i = 0; i < nameKidsElements.size(); i++) {
 Element kid = nameKidsElements.get(i);
 allAttrMap = getNodeAttrMap(kid);
 mostKidsAllAttriMap.put(i, allAttrMap);
 }
 return (T) mostKidsAllAttriMap;
 default:
 break;
 }
 return null;
 }
 
 /**
 * @param element
 * 方法功能描述:遍历指定的节点下所有的节点
 * 方法名:ransack
 * 参数描述 :
 * 返回类型：void
 * 时间：2011-4-18下午05:25:41
 */
 public static List<Element> ransack(Element element, List<Element> allkidsList) {
 if (element == null) {
 return null;
 }
 if (hasChild(element)) {
 List<Element> kids = getChildList(element);
 for (Element e : kids) {
 allkidsList.add(e);
 ransack(e, allkidsList);
 }
 }
 return allkidsList;
 }
 
 /**
 * @param element
 * @param nodeName
 * @return 参数描述 :
 * 方法功能描述:得到指定节点下的指定节点集合
 * 方法名:getNameElement
 * 返回类型：Element
 * 时间：2011-4-18下午06:18:56
 */
 public static List<Element> getNameElement(Element element, String nodeName) {
 nodeName = nodeName.trim();
 List<Element> kidsElements = new ArrayList<Element>();
 if (element == null) {
 return null;
 }
 if (nodeName == null || "".equals(nodeName)) {
 return null;
 }
 List<Element> allKids = ransack(element, new ArrayList<Element>());
 if (allKids == null) {
 return null;
 }
 for (int i = 0; i < allKids.size(); i++) {
 Element kid = allKids.get(i);
 if (nodeName.equals(kid.getName())) {
 kidsElements.add(kid);
 }
 }
 return kidsElements;
 }
 
 /**
 * @param element
 * 方法功能描述:验证节点是否唯一
 * 方法名:validateSingle
 * 返回类型：int 节点唯一返回1, 节点不唯一返回大于一的整型数据
 * 时间：2011-4-20下午04:36:22
 */
 public static int validateSingle(Element element) {
 int j = 1;
 if (element == null) {
 return j;
 }
 Element parent = element.getParent();
 List<Element> kids = getChildList(parent);
 for (Element kid : kids) {
 if (element.equals(kid)) {
 j++;
 }
 }
 return j;
 }
 
 }

CfgHero.java                            对应Hero.xml中的hero标签

package com.lizhaoblog.server.biz.entity.cfg;
    
    import java.io.Serializable;
    
    import javax.xml.bind.annotation.XmlAccessType;
    import javax.xml.bind.annotation.XmlAccessorType;
    import javax.xml.bind.annotation.XmlAttribute;
    import javax.xml.bind.annotation.XmlRootElement;
    
    @XmlRootElement(name = "Hero")
    @XmlAccessorType(XmlAccessType.FIELD)
    public class CfgHero implements Serializable {
        @XmlAttribute(name = "id")
        private int id;
        @XmlAttribute(name = "roleId")
        private int roleId;
        @XmlAttribute(name = "name")
        private String name;
        @XmlAttribute(name = "type")
        private int type;
        @XmlAttribute(name = "countryType")
        private int countryType;
        @XmlAttribute(name = "icon")
        private String icon;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public int getRoleId() {
            return roleId;
        }
    
        public void setRoleId(int roleId) {
            this.roleId = roleId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getType() {
            return type;
        }
    
        public void setType(int type) {
            this.type = type;
        }
    
        public int getCountryType() {
            return countryType;
        }
    
        public void setCountryType(int countryType) {
            this.countryType = countryType;
        }
    
        public String getIcon() {
            return icon;
        }
    
        public void setIcon(String icon) {
            this.icon = icon;
        }
    }

ConfigDataArrCfgHero.java                对应Hero.xml文件

package com.lizhaoblog.server.biz.entity.cfg;
 
 import com.lizhaoblog.base.xml.ConfigDataArr;
 
 import java.util.List;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElements;
 import javax.xml.bind.annotation.XmlRootElement;
 
 @XmlRootElement(name = "Root")
 @XmlAccessorType(XmlAccessType.FIELD)
 public class ConfigDataArrCfgHero implements ConfigDataArr {
 
 @XmlElements(value = {@XmlElement(name = "Hero", type = CfgHero.class)})
 private List<CfgHero> cfgHeroes;
 
 public List<CfgHero> getCfgHeroes() {
 return cfgHeroes;
 }
 
 public void setCfgHeroes(List<CfgHero> cfgHeroes) {
 this.cfgHeroes = cfgHeroes;
 }
 
 @Override
 public List getList() {
 return getCfgHeroes();
 }
 }

Hero.xml                                Hero的配置

<?xml version="1.0" encoding="utf-8"?>
 
 
 <Root>
 <Hero id="1" roleId="1001" name="曹操" type="1" countryType="1" icon="ui://rgylkpibej3p9"/>
 <Hero id="2" roleId="1002" name="刘备" type="2" countryType="2" icon="ui://rgylkpibej3p8"/>
 <Hero id="3" roleId="1003" name="孙权" type="3" countryType="3" icon="ui://rgylkpibej3p5"/>
 </Root>

dataConfig.xml                                所有配置数据的清单文件

<?xml version="1.0" encoding="UTF-8"?>
 <config>
 	<file name="Hero" />
 </config>

ConfigDataManagerTest.java                    测试类

/*
 * Copyright (C), 2015-2018
 * FileName: ConfigDataManagerTest
 * Author: zhao
 * Date: 2018/7/24 16:40
 * Description: ConfigDataManager的测试类
 * History:
 * <author> <time> <version> <desc>
 * 作者姓名 修改时间 版本号 描述
 */
 package com.lizhaoblog.base.xml;
 
 import com.lizhaoblog.base.exception.XmlConfigReadException;
 
 import org.junit.Test;
 
 import java.util.List;
 import java.util.Map;
 
 /**
 * 〈一句话功能简述〉 
 * 〈ConfigDataManager的测试类〉
 *
 * @author zhao
 * @date 2018/7/24 16:40
 * @since 1.0.1
 */
 public class ConfigDataManagerTest {
 
 @Test
 public void testLoadXml() throws XmlConfigReadException {
 String cfgPackageName = "com.lizhaoblog.server.biz.entity.cfg.";
 String cfgPrefix = "ConfigDataArrCfg";
 String catalogDir = "/cfg/";
 String catalogFile = "dataConfig.xml";
 String catalogMainNode = "/config/file";
 String catalogAttribute = "name";
 String xmlFileDir = "/cfg/data-static-config/";
 ConfigDataManager.getInstance()
 .loadXml(cfgPackageName, cfgPrefix, catalogDir, catalogFile, catalogMainNode, catalogAttribute, xmlFileDir);
 Map<String, List<?>> configDataMap = ConfigDataManager.getInstance().getConfigDataMap();
 }
 
 }

上面的代码在码云上 https://gitee.com/lizhaoandroid/JgServer  
        可以加qq群一起探讨Java游戏服务器开发的相关知识    676231564