XMLSchema(XSD)解析类

最新推荐文章于 2022-03-18 18:07:01 发布
最新推荐文章于 2022-03-18 18:07:01 发布
阅读量324 收藏 1
点赞数
分类专栏： XSLT 文章标签： XML Blog

参考资料：http://feihu1117.iteye.com/blog/660289

 

二话不说，上代码。好吧。。。我承认不解析dtd而直接写成字符串是不好的，但是能抓老鼠的都是好猫嘛

 

package ejbModule.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;


/**
 * schema解析与xml构建类<br>
 * 提供四个静态方法:<br>
 * 1、SchemaUtil.parseXSD 解析<br>
 * 2、SchemaUtil.createXML 创建<br>
 * 3、SchemaUtil.updateXML 修改<br>
 * 4、SchemaUtil.sortXMLNodes 排序
 * @author LZY
 */
@SuppressWarnings("unchecked")
public class SchemaUtil 
{
	/** xml修改类型：增加节点 */
	public final static String UPDATETYPE_ADD = "A";
	/** xml修改类型：修改节点 */
	public final static String UPDATETYPE_MODIFY = "M";
	/** xml修改类型：删除节点 */
	public final static String UPDATETYPE_DEL = "D";
	/** schema定义的节点集合 */
	private static List<XSDNode> list = null; 
	
	/**
	 * 解析XSD，返回数据节点对象列表
	 * @param xsd xml schema 
	 * @param rootName 指定作为根节点的元素名称
	 * @return XSDNode元素列表
	 * @throws Exception
	 */
	public static List<XSDNode> parseXSD(String xsd, String rootName) throws Exception
	{
		try{
			list = new ArrayList<XSDNode>();
			Document doc = DocumentHelper.parseText(xsd);
			Element rootElement = doc.getRootElement();
			String path=XMLConstants.XSD_DEFAULT_NAMESPACE+ ":element[@name=\"" + rootName + "\"]";
			Element targetElement = (Element) rootElement.selectSingleNode(path);
			parseData(rootElement, targetElement, "/", targetElement.getPath());
			return list;
		}catch (Exception e)
		{
			e.printStackTrace();
			return null;
		}
		
	}
	
	/**
	 * 根据schema和valueMap生成xml<br>
	 * XML生成规则：某节点的出现位置由valueMap的XPath路径(键)指定，不指定则默认按schema指定，即最少出现一次<br>
	 * 例："/book/column[3]/id"表示第三个/book/column下的id节点<br>
	 * 　　"/book/column[3]/@id"表示第三个/book/column的id属性
	 * @param xsd schema字符串
	 * @param rootName 根节点元素名
	 * @param valueMap "XPath路径,元素值"形式的键值对
	 * @return xml
	 */
	public static String createXML(String xsd,String rootName,HashMap<String, String> valueMap)
	{
		try 
		{
			List<XSDNode> xsdNodeList = parseXSD(xsd,rootName);
			
			Document document = DocumentHelper.createDocument();
			//先根据valueMap生成xml
			createNodesByValueMap(document,valueMap);
			//然后使用schema补充无值节点
			fillNodesByXSDNodes(document,xsdNodeList);
			return document.asXML();
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
			return "";
		}
	}
	
	/**
	 * 根据valueMap修改xml,非SchemaUtil.UPDATETYPE_ADD情况可不传入xsd<br>
	 * XML修改规则：<br>
	 * 　　1、某位置节点的增加由valueMap的XPath路径(键)及(值)指定，默认按schema指定<br>
	 * 　　2、某位置节点的修改由valueMap的XPath路径(键)及(值)指定，不指定则不修改<br>
	 * 　　3、某位置节点的删除由valueMap的XPath路径(键)及(值)指定，含子节点全部删除<br>
	 * 例："/book/column[3]/id"表示在第三个/book/column下增加id节点<br>
	 * @param xsd schema字符串
	 * @param xml 修改的xml字符串
	 * @param updateType 1、SchemaUtil.UPDATETYPE_ADD<br>
	 * 　　　　　　2、SchemaUtil.UPDATETYPE_MODIFY<br>
	 * 　　　　　　3、SchemaUtil.UPDATETYPE_DEL
	 * @param valueMap "XPath路径,元素值"形式的键值对
	 * @return xml
	 */
	public static String updateXML(String xsd,String xml,String updateType,HashMap<String, String> valueMap)
	{
		try 
		{
			Document document = DocumentHelper.parseText(xml);
			if(SchemaUtil.UPDATETYPE_ADD.equals(updateType))
			{
				List<XSDNode> xsdNodeList = parseXSD(xsd,document.getRootElement().getName());
				createNodesByValueMap(document,valueMap);
				fillNodesByXSDNodes(document,xsdNodeList);
			}
			else if(SchemaUtil.UPDATETYPE_MODIFY.equals(updateType))
			{
				Iterator iterator = valueMap.entrySet().iterator();
				while(iterator.hasNext())
				{
				    Entry<String, String> entry = (Entry<String, String>)iterator.next();
				    Node node = document.selectSingleNode(entry.getKey());
				    if(node == null)//无此节点时先创建节点
				    {
				    	HashMap<String, String> tmpValueMap = new HashMap<String, String>();
				    	tmpValueMap.put(entry.getKey(), entry.getValue());
				    	
				    	List<XSDNode> xsdNodeList = parseXSD(xsd,document.getRootElement().getName());
						createNodesByValueMap(document,tmpValueMap);
						fillNodesByXSDNodes(document,xsdNodeList);
				    	
				    	node = document.selectSingleNode(entry.getKey());
				    }
				    	
				    node.setText(entry.getValue());
				}
			}
			else if(SchemaUtil.UPDATETYPE_DEL.equals(updateType))
			{
				List<Node> toDel = new ArrayList<Node>(); 
				Iterator iterator = valueMap.entrySet().iterator();
				while(iterator.hasNext())
				{
				    Entry<String, String> entry = (Entry<String, String>)iterator.next();
				    Node node = document.selectSingleNode(entry.getKey());
				    if(node != null) toDel.add(node);
				}
				iterator = toDel.iterator();
				while(iterator.hasNext())
				{
					Node node = (Node)iterator.next();
					node.getParent().remove(node);
				}
			}
			return document.asXML();
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
			return "";
		}
	}
	
	/**
	 * 对给出的XML，指定进行排序的节点和排序方式，进行排序<br>
	 * 调用例:sortXMLNodes(xml, "/book/column", "order", true)
	 * @param xml 进行排序的XML
	 * @param xPath 进行排序的节点集，其XPath路径
	 * @param cmpName 排序依据值其元素XPath，可为属性或节点名称
	 * @param bIsAesc 升序(true)/降序(false)
	 * @return 排序结束后的xml
	 */
	public static String sortXMLNodes(String xml,String xPath,String cmpName,boolean bIsAesc)
	{
		try
		{
			Document document = DocumentHelper.parseText(xml);
	    	List<Element> nodes = document.selectNodes(xPath,cmpName);
	    	if(bIsAesc == false)
	    		Collections.reverse(nodes); //降序 
	    	for(Element e : nodes) 
	    	{ 
	    		Element parent = e.getParent();
	    		parent.remove(e);
	    		parent.add(e);
	    	}
	    	
	    	return document.asXML();
		}
		catch (Exception e)
		{
			e.printStackTrace();
			return "";
		}
		
	}
	
	/**
	 * 根据ValueMap创建XML节点
	 * @param document xml dom
	 * @param valueMap 值集合
	 * @throws Exception
	 */
	private static void createNodesByValueMap(Document document, HashMap<String, String> valueMap) throws Exception
	{
		Iterator iterator = valueMap.entrySet().iterator();
		while(iterator.hasNext())
		{
		    Entry<String, String> entry = (Entry<String, String>)iterator.next();
		    String key = entry.getKey();
		    
		    StringTokenizerCloneable tokens = new StringTokenizerCloneable(key, "/");
		    Element parent = document.getRootElement(); 
		    String name = tokens.nextToken();
			if (parent == null) parent = document.addElement(name);
		    Element element = null;
			while (tokens.hasMoreTokens())
			{
				name = tokens.nextToken();
				if (name.indexOf(':') > 0)
				{
					element = parent.element(parent.getQName(name));
				}
				else if(name.indexOf("@") == 0)
				{
					name = name.substring(1);
					parent.addAttribute(name, "");
					break;
				}
				else
				{
					element = parent.element(name);
				}
				if (element == null)
				{
					Pattern pa = Pattern.compile("\\[.*?\\]");
				    Matcher ma = pa.matcher(name);
				    if(ma.find())
					{
				    	String pos = ma.group();//位置号
				    	name = name.substring(0,name.indexOf("["));//节点名
				    	
				    	List<Element> elList = parent.elements(name);
				    	int iElNum = elList == null?0:elList.size();
				    	int iPos = 0;
				    	try
						{
				    		iPos = Integer.valueOf(pos.substring(1,pos.length() - 1));
						}
						catch (Exception e){iPos = iElNum;}
				    	
				    	int iDiff = iPos - iElNum;//给定位置与实际节点数的差
				    	while(iDiff > 0)
			    		{//补充缺少节点
				    		parent.addElement(name);//创建同名节点
			    			iDiff --;
			    		}
				    	elList = parent.elements(name);
				    	element = elList.get(iPos - 1);
					}
				    else 
				    	element = parent.addElement(name);
				}
				parent = element;
			}
			document.selectSingleNode(key).setText(entry.getValue());
		}
	}
	
	/**
	 * 根据schema元素填充无值XML节点
	 * @param document xml dom
	 * @param xsdNodeList schema元素集合
	 * @throws Exception
	 */
	private static void fillNodesByXSDNodes(Document document, List<XSDNode> xsdNodeList) throws Exception
	{
		for(int i=0;i < xsdNodeList.size();i++)
		{
		    String path = xsdNodeList.get(i).getXPath();
		    StringTokenizerCloneable tokens = new StringTokenizerCloneable(path, "/");
		    Element parent = document.getRootElement(); 
		    String name = tokens.nextToken();
			if (parent == null) parent = document.addElement(name);
		    
		    if (tokens.hasMoreTokens()) fillNodes(parent,tokens,tokens.nextToken());
		}
	}
	
	/**
	 * 递归填充无值XML节点
	 * @param parent 父节点
	 * @param tokens 记号
	 * @param name 当前节点名
	 * @throws Exception
	 */
	private static void fillNodes(Element parent,StringTokenizerCloneable tokens,String name) throws Exception
	{
		if(name.indexOf("@") == 0)
		{
			name = name.substring(1);
			if(parent.attribute(name) == null) parent.addAttribute(name, ""); 
			return;
		}
		
	    List<Element> elements = null;
	    elements = getElements(parent,name);
		if (elements == null || elements.size() == 0)
		{
			parent.addElement(name);
			elements = getElements(parent,name);
		}
		else 
		{//调整顺序，把已有节点放到最后
			int iEl = elements.size();
			for(int i=0;i < iEl;i++)
			{
				Element element = elements.get(0).createCopy();
				parent.remove(elements.get(0));
				parent.add(element);
				//修改后取回引用
				elements = getElements(parent,name);
			}
		}
		if (tokens.hasMoreTokens())
		{
			for(int i=0;i < elements.size();i++)
			{
				StringTokenizerCloneable clone = (StringTokenizerCloneable)tokens.clone();
				fillNodes(elements.get(i), clone, clone.nextToken());
			}
		}
	}
	
	/**
	 * 获取Element集合
	 * @param parent 父节点
	 * @param name Element节点名
	 * @return Element集合
	 */
	private static List<Element> getElements(Element parent,String name) throws Exception
	{
		List<Element> elements = null;
		if (name.indexOf(':') > 0)
		{
			elements = parent.elements(parent.getQName(name));
		}
		else
		{
			elements = parent.elements(name);
		}
		return elements;
	}
	
	/**
	 * 转换XSD的数据节点，生成XSDNode对象
	 * @param rootElement 根元素
	 * @param element 当前元素
	 * @param xPath 当前元素在xml中的xpath路径
	 * @param xsdPath  当前xsd元素在schema中的xpath路径
	 */
	private static void parseData(Element rootElement,Element element, String xPath, String xsdPath) throws Exception
	{
		String nodeRef = element.attributeValue("ref");
		if(nodeRef != null)//存在ref属性的引用情况
		{
			Element refElement = (Element)rootElement.selectSingleNode(XMLConstants.XSD_DEFAULT_NAMESPACE + ":element[@name=\""+ nodeRef +"\"]");
			xsdPath = refElement.getPath();
			element = refElement;
		}
		//获取节点name属性
		String nodeName = element.attributeValue("name");
		//组装xml文档中节点的XPath
		xPath += nodeName;
		//组装下一个element元素的XPath
		
		String cpxXsdPath = xsdPath + "[@name=\"" + nodeName + "\"]" + "/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":complexType/";
		String currentXsdPath = cpxXsdPath 
								+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":sequence/" 
								+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":element";
		
		//自定义复杂类型
		if (element.attribute("type") != null && element.attribute("type").getText().indexOf(XMLConstants.XSD_DEFAULT_NAMESPACE + ":") < 0)
		{
			Element typeElement = (Element)rootElement.selectSingleNode(XMLConstants.XSD_DEFAULT_NAMESPACE + ":complexType[@name=\""+ element.attribute("type").getText() +"\"]");
			xsdPath = typeElement.getPath();
			cpxXsdPath = xsdPath + "[@name=\"" + nodeName + "\"]" + "/";
			currentXsdPath = cpxXsdPath
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":sequence/" 
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":element"; 
		}
		parseAttr(rootElement,cpxXsdPath,xPath);
		//查找该节点下所有的element元素
		List<Node> elementNodes = element.selectNodes(currentXsdPath);
		if(elementNodes != null && elementNodes.size() > 0)
		{//如果下面还有element,说明不是叶子
			Iterator<Node> nodes = elementNodes.iterator();
			while (nodes.hasNext())
			{
				if (!xPath.endsWith("/"))
				{
					xPath += "/";
				}
				Element ele = (Element) nodes.next();
				parseData(rootElement, ele, xPath, currentXsdPath);
			}
		}
		else
		{ 	
			//获取节点类型属性
			String nodeType = "";
			Attribute type = element.attribute("type");
			if (type != null) nodeType = type.getText();
			else
			{//该element为叶子
				String spath = xsdPath + "[@name=\"" + nodeName + "\"]/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":simpleType/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":restriction";
				Element typeNode = (Element) element.selectSingleNode(spath);
				if (typeNode == null)//另一方式
				{
					spath = xsdPath + "[@name=\"" + nodeName + "\"]/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":complexType/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":simpleContent/"
							+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":extension";
					
					typeNode = (Element) element.selectSingleNode(spath);
				}
				
				if (typeNode != null)
				{
					Attribute base = typeNode.attribute("base");
					if (base != null) nodeType = base.getText();
				}
			}
			XSDNode xsdNode = new XSDNode();
			xsdNode.setName(nodeName);
			xsdNode.setXPath(xPath);
			xsdNode.setType(nodeType);
			list.add(xsdNode);
		}
	}
	
	/**
	 * 解析节点属性
	 * @param rootElement 根节点
	 * @param cpxXsdPath 复杂类型节点路径
	 */
	private static void parseAttr(Element rootElement,String cpxXsdPath,String xPath) throws Exception
	{
		String attrPath1 = cpxXsdPath + XMLConstants.XSD_DEFAULT_NAMESPACE + ":attribute";
		List<Element> attrList = rootElement.selectNodes(attrPath1);
		if(attrList != null && attrList.size() > 0)
		{
			for(int i=0;i<attrList.size();i++)
			{
				addAttr(rootElement,attrList.get(i),xPath);
			}
		}
		
		String attrPath2 = cpxXsdPath 
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":simpleContent/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":extension/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":attribute";
		attrList = rootElement.selectNodes(attrPath2);
		if(attrList != null && attrList.size() > 0)
		{
			for(int i=0;i<attrList.size();i++)
			{
				addAttr(rootElement,attrList.get(i),xPath);
			}
		}
	}
	
	/**
	 * 把节点属性加入元素列表
	 * @param rootElement 根节点
	 * @param element 属性描述节点
	 * @param xPath 属性所属节点xPath
	 */
	private static void addAttr(Element rootElement,Element element,String xPath) throws Exception
	{
		String nodeRef = element.attributeValue("ref");
		if(nodeRef != null)//存在ref属性的引用情况
		{
			Element refElement = (Element)rootElement.selectSingleNode(XMLConstants.XSD_DEFAULT_NAMESPACE + ":attribute[@name=\""+ nodeRef +"\"]");
			element = refElement;
		}
		
		String name = element.attributeValue("name");
		
		//获取节点类型属性
		String nodeType = "";
		Attribute type = element.attribute("type");
		if (type != null) nodeType = type.getText();
		else
		{//该element为叶子
			String spath = element.getPath() + "/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":simpleType/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":restriction";
			Element typeNode = (Element) element.selectSingleNode(spath);
			if (typeNode == null)//另一方式
			{
				spath = element.getPath() + "/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":complexType/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":simpleContent/"
						+ XMLConstants.XSD_DEFAULT_NAMESPACE + ":extension";
				
				typeNode = (Element) element.selectSingleNode(spath);
			}
			
			if (typeNode != null)
			{
				Attribute base = typeNode.attribute("base");
				if (base != null) nodeType = base.getText();
			}
		}
		
		XSDNode xsdNode = new XSDNode();
		xsdNode.setName(name);
		xsdNode.setXPath(xPath + "/@" + name);
		xsdNode.setType(nodeType);
		list.add(xsdNode);
	}
	
	/**
	 * xsd元素对象
	 */
	public static class XSDNode
	{
		/** 元素名称 */
		private String name;
		/** 元素XPath */
		private String xPath;
		/** 元素类型 */
		private String type;

		public String getName()
		{
			return name;
		}
		public void setName(String name)
		{
			this.name = name;
		}
		public String getXPath()
		{
			return xPath;
		}
		public void setXPath(String path)
		{
			xPath = path;
		}
		public String getType()
		{
			return type;
		}
		public void setType(String type)
		{
			this.type = type;
		}
	}
	
	/**
	 * xsd固定名称字符串
	 */
	private static class XMLConstants
	{
		/** xml编码 */
		public static final String ENCODING = "UTF-8";
		/** xsd默认命名空间 */
		public static final String XSD_DEFAULT_NAMESPACE = "xs";
		/** xsd复合类型节点 */
		public static final String XSD_COMPLEX_TYPE = "complexType";
		/** xsd序列节点 */
		public static final String XSD_SEQUENCE = "sequence";
		/** xsd元素节点 */
		public static final String XSD_ELEMENT = "element";
		/** xsd注解节点 */
		public static final String XSD_ANNOTATION = "annotation";
		/** xsd注解文档节点 */
		public static final String XSD_DOCUMENTATION = "documentation";
		/** xsd简单类型节点 */
		public static final String XSD_SIMPLE_TYPE = "simpleType";
		/** xsd限制节点 */
		public static final String XSD_RESTRICTION = "restriction";
		/** xsd name属性 */
		public static final String XSD_ATTRIBUTE_NAME = "name";
		/** xsd type属性 */
		public static final String XSD_ATTRIBUTE_TYPE = "type";
		/** xsd base属性 */
		public static final String XSD_ATTRIBUTE_base = "base";
	} 
	
	/**
	 * 可复制对象的StringTokenizer类
	 */
	private static class StringTokenizerCloneable extends StringTokenizer implements Cloneable
	{
		public StringTokenizerCloneable(String str, String delim, boolean returnDelims)
		{
			super(str,delim,returnDelims);
		}
		
		public StringTokenizerCloneable(String str, String delim) 
		{
			super(str, delim);
		}
		
		public StringTokenizerCloneable(String str) 
		{
			super(str);
		}
		
	    public Object clone()
	    {
	    	StringTokenizerCloneable o = null;
	        try
	        {
	            o = (StringTokenizerCloneable)super.clone();
	        }
	        catch(CloneNotSupportedException e)
	        {
	            e.printStackTrace();
	        }
	        return o;
	    }
	}
}
iteye_258
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
XsdParser：一种将XSD文件解析为Java结构的解析器
02-06
XsdParser XsdParser是一个将XML定义文件（.xsd）解析为Java对象列表的库。 每个不同的XSD标记都有一个对应的Java类，并且给定XSD类型的属性表示为该类的字段。 所有这些类都源自同一抽象类XsdAbstractElement 。 XSD元素的所有Java表示形式都遵循XSD的架构定义。 例如， xsd：annotation标记仅允许xsd：appinfo和xsd：documentation作为子节点，并且还可以具有名为id的属性，因此XsdParser具有以下类（出于示例目的而进行了简化）： public class XsdAnnotation extends
读取Schema文件(XmlSchema.Read())
safewolf的专栏
03-17 1693
//将文件读出,生成Stream对象System.IO.FileStream myStream = new System.IO.FileStream("c//test.xsd",System.IO.FileMode.OpenOrCreate);//生成Schema对象System.Xml.Schema.XmlSchema mySchema = System.Xml.Schema.XmlSchema
XML Schema - 应用程序中读取和创建XSD - (四) XSD强大的数据类型之各种数据类型
Josh_Persistence
05-20 193
[i][b]XSD 字符串数据类型[/b][/i] 字符串数据类型用于可包含字符串的值。 字符串数据类型（String Data Type） 字符串数据类型可包含字符、换行、回车以及制表符。 下面是一个关于某个 scheme 中字符串声明的例子： 文档中的元素看上去应该类似这样： John Smith 或者类似这样： John Smith ...
XML Schema (XSD) 学习总结，解读XML Schema（XSD）各个元素和属性的含义
L_ZG_的博客
04-07 9056
云中君说： 学习XSD是我在学习框架的时候，希望认识和深刻学习框架中xml的配置，进而开始学习xsd。所以一大部分学习案例来自于W3School和String MVC框架的配置文件的xml引用的命名空间。 建议学习这个XSD的小伙伴可以先了解一下我的XML学习总结，在学习这一部分的内容！ 如果在学习中发现我的以下问题和错误，可以私信告诉我，也可以在评论区留言给我，我们一起学习一起进步，谢谢大家的支...
XML Schema - 应用程序中读取和创建XSD - (三) XSD强大的数据类型之复杂类型
Josh_Persistence
05-20 117
XSD 复合元素 复合元素包含了其他的元素及/或属性。 什么是复合元素？ 复合元素指包含其他元素及/或属性的 XML 元素。 有四种类型的复合元素： 空元素 包含其他元素的元素 仅包含文本的元素 包含元素和文本的元素 注释：上述元素均可包含属性！ [b][i]复合元素的例子[/i][/b] 复合元素，"product"，是空的：...
Java通过XML Schema校验XML
11-06
　校验的原理是通过读取解析XML的时候设置校验的XSD和校验错误处理器，顺便校验的。 　下面不扯这些废话了，我用DOM4j结合javaxml api使用XSD来校验一个xml有效性，下面这个例子虽然和蹩脚，但是也费了一番功夫，放...
XSD（XML Schemas Definition）
03-16
XML Schema语言也就是XML Schema Definition (XSD)。 XML Schema描述了XML文档的结构。可以用一个指定的XML Schema来验证某个XML文档，以检查该XML文档是否符合其要求。文档设计者可以通过XML Schema指定一个XML文档...
XML_SCHEMA教程
02-15
XML SCHEMA教程 比较详细，XML Schema是W3C制定的基于XML格式的XML文档结构描述标准...使用XSD，我们不仅可以描述XML文档的结构以便颁布业务标准，而且可以使用支持XSD的通用化XML解析器对XML文档进行解析并自动地检查
erlsom：用于Erlang的XML解析器
02-06
erlsom：用于Erlang的XML解析器
XML Schema - 应用程序中读取和创建XSD - (二) XSD强大的数据类型之简单类型
Josh_Persistence
05-20 201
[i][b]XSD 简易元素[/b][/i] XML Schema 可定义 XML 文件的元素。 简易元素指那些只包含文本的元素。它不会包含任何其他的元素或属性。 什么是简易元素？ 简易元素指那些仅包含文本的元素。它不会包含任何其他的元素或属性。 不过，“仅包含文本”这个限定却很容易造成误解。文本有很多类型。它可以是 XML Schema 定义中包括的类型中的一种...
xsd解析实例创建表结构
12-19
解析xsd文件，将需要的属性封装成List，循环遍历List集合，拼接sql语句，创建表结构
XML解析 验证之XSD和DTD验证以及 SpringXML验证源码分析
大佛拈花的博客
09-25 803
1.DTD(Documnet Type Definition) DTD即文档类型定义，是一种XML约束模式语言，是XML文件的验证机制,属于XML文件组成的一部分。 DTD 是一种保证XML文档格式正确的有效方法，可以通过比较XML文档和DTD文件来看文档是否符合规范，元素和标签使用是否正确。 一个 DTD文档包含： 元素的定义规则，元素间关系的定义规则，元素可使用的属性，可使用的实体或符号规...
xml之数据解析及schema解析
移动开发记录
09-13 474
一、XML数据解析方式： 1 DOM方式 Document Object Model，文档对象模型。这种方式是W3C推荐的处理XML的一种方式。把XML文档当做一个树对待；对于增删改查非常地方便。 缺点：构造此树，必须先将整个文档加载进内存，比较费时费内存，当文件很大时有可能会造成内存溢出。 引用的包是:org.w3c.*; 2 SAX方式（推—被动式的）SimpleAPI for XML...
XML Schema(XSD)详解
深蓝至尊
02-28 5482
下面对于XSD的介绍，会有对应的解释和例子，一目了然。&lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3school.com.cn" xmlns="http://www.w3
XSD工具简介
weixin_30699235的博客
07-13 1706
XSD使用方法介绍 XSD工具位于：C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin目录下。XSD工具有很多功能，如下： 1、将XDR 转换 XSD 使用精简 XML 数据架构文件生成 XML 架构。 XDR 为早期基于 XML 的架构格式。 2、XML转换XSD 使用 XML 文件生成 XML 架构。 3、XSD...
JAVA 实现从xsd 解析成xml，无套路上代码
qq_22597325的博客
03-18 1953
java 实现XSD 转 xml 全流程
java xsd解析_java dom4j解析XSD文件
weixin_32880357的博客
02-16 1825
1.用DOM4J解析XSD文件，找出XSD文件中所有的element,type的定义，(xsd文件有4W多行)，最终找出的结果是element和type定义有6000多个，2.递归找出指定type所用到的所有关联的元素，其中有用到XPATH来查找结点根据type在xsd文件中查找，找到有type和element是自定义的就递归下去继续往下找，直到找到最后所有的type和element都是XSD自带...
一个JAVA的XSD解析问题的解决
goflyfreely的专栏
11-25 3806
现在很多XML配置文件都引入XSD来简化配置。Spring在加载这些配置的时候就可能会遇到问题： nested exception is org.xml.sax.SAXParseException; lineNumber: 6; columnNumber: 9; cvc-complex-type.2.4.c: 通配符的匹配很全面, 但无法找到元素 'config' 的声明。
java xsd解析_在Java中,如何解析xml架构(xsd)以了解在给定...
weixin_42166626的博客
02-12 340
我希望能够读取XML模式(即xsd),并从中了解当我浏览它时有效的属性,子元素,值.例如,假设我有一个xsd,这个xml将验证：blahblahblah我已经修改了几个库,我可以放心地得到< root>作为根元素.除此之外,我迷失了.给定一个元素我需要知道哪些子元素是必需的或允许的,属性,方面,选择等.使用上面的例子,我想知道元素-a有一个属性类型,可能有子元素-b和元素-c …或必须...
XML Schema
最新发布
10-13
XML Schema是一种用于描述和验证XML文档结构的语言。它可以定义元素、属性、数据类型和命名空间等内容，并且可以通过验证器来检查XML文档是否符合定义的规则。 与DTD相比，XML Schema具有更强的表达能力和灵活性，可以定义更复杂的数据类型和结构，并且支持命名空间和模块化等特性。 XML Schema通常以XSD文件的形式存在，可以通过各种编程语言的解析器或验证器来解析和验证XML文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值