`
lushuaiyin
  • 浏览: 704906 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

解析xml和生成xml（使用dom4j和velocity）

 
阅读更多

在项目中队xml的解析和生成几乎每个程序员都要遇到。既然如此，对这个不熟悉就说不过去了，打好基础吧。

现在学习如何对xml解析和怎样生成xml。

首先，写一个xml，作为我们研究的样本。

XmlMessage.xml

<?xml version="1.0" encoding="UTF-8"?>
<transaction name="BuyBooks">
	<header>
		<title name="charset">UTF-8</title>
		<title name="system">MALL</title>
	</header>
	<body>
		<field attr="word">Welcome</field>
		<field attr="people">all you guys</field>
		<array>
		    <book key="bookId">100010</book>
		    <book key="bookName">唐诗300首</book>
		    <book key="bookPrice">21元</book>
		    <book key="bookQuantity">135本</book>
		</array>
		<array>
		    <book key="bookId">100012</book>
		    <book key="bookName">宋词</book>
		    <book key="bookPrice">15元</book>
		    <book key="bookQuantity">121本</book>
		</array>
	</body>
</transaction>

好，现在我们就把这个作为研究的样本来看看怎解析它。

Java是面向对象编程的，所以第一步，你肯定想到了，解析后的内容要放在一个变量里。

这样在需要时就直接对变量进行操作了。

那么对应这个xml，我们应该对变量配置那些属性呢？

其实，这个要根据你的业务来定了。比如，在这个xml中，

<header>
<title name="charset">UTF-8</title>
<title name="system">MALL</title>
</header>

这部分是必然有的，

<field attr="word">Welcome</field>
<field attr="people">all you guys</field>

也是必然有的，唯一就是那个

<array>
<book key="bookId">100010</book>
<book key="bookName">唐诗300首</book>
<book key="bookPrice">21元</book>
<book key="bookQuantity">135本</book>
</array>

可有可无，也可由多个。

针对这样的业务，我们就把必有的属性都配置一个属性，多个或没有的就配置成一个容器（比如List）。

这个看你的业务了，如果里面的属性变化太大，则可以具体细分成多个对象定义成一个总的对象。

总之，要把对象的属性和xml中定义的一一对应就可以。

针对这个xml，我这样定义：

XmlMessage

package org.xml.bean;

import java.util.ArrayList;
import java.util.List;

public class XmlMessage {
	private String charset;
	private String system;
	private String word;
	private String people;
	private List<Book> array=new ArrayList<Book>();
	
	private String transaction;
	
	public String getCharset() {
		return charset;
	}
	public void setCharset(String charset) {
		this.charset = charset;
	}
	public String getSystem() {
		return system;
	}
	public void setSystem(String system) {
		this.system = system;
	}
	public String getWord() {
		return word;
	}
	public void setWord(String word) {
		this.word = word;
	}
	public String getPeople() {
		return people;
	}
	public void setPeople(String people) {
		this.people = people;
	}
	public List<Book> getArray() {
		return array;
	}
	public void setArray(List<Book> array) {
		this.array = array;
	}
	public String getTransaction() {
		return transaction;
	}
	public void setTransaction(String transaction) {
		this.transaction = transaction;
	}
}
Book 

package org.xml.bean;

public class Book {
	private String bookId;
	private String bookName;
	private String bookPrice;
	private String bookQuantity;
	
	public String getBookId() {
		return bookId;
	}
	public void setBookId(String bookId) {
		this.bookId = bookId;
	}
	public String getBookName() {
		return bookName;
	}
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}
	public String getBookPrice() {
		return bookPrice;
	}
	public void setBookPrice(String bookPrice) {
		this.bookPrice = bookPrice;
	}
	public String getBookQuantity() {
		return bookQuantity;
	}
	public void setBookQuantity(String bookQuantity) {
		this.bookQuantity = bookQuantity;
	}
	
	
}

现在看出对应关系了吧。

在开始之前，先写一个打印对象的方法，只要能打印出对象的属性和值就可以。一般可以使用toString（）方法，

但是我建议写成json格式的，应为在web层页面需要处理对象的时候，使用json很方便。这里只是为了打印。

JsonUtil

package org.xml.util;

import net.sf.json.JSONObject;

public class JsonUtil{
	
	public static String objectToJson(Object obj){
		String result="";
		if(obj!=null){
			try{
				result=JSONObject.fromObject(obj).toString();
			}catch(Exception ee){
				 ee.printStackTrace();
			}
		}
        return result;      
    }
	

    public static void main(String[] arg) throws Exception{   
    	
    }   
}

准备工作都做好了，现在开始解析。

对于解析xml，首选当然是dom4j。

写一个工具类

Dom4jXmlUtil

package org.xml.util;

import java.io.File;
import java.io.InputStream;
import java.io.StringReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.DOMReader;
import org.dom4j.io.SAXReader;
import org.xml.bean.Book;
import org.xml.bean.XmlMessage;
import org.xml.sax.InputSource;

public class Dom4jXmlUtil {
    
	public Dom4jXmlUtil() {}
    
    public static SAXReader createSAXReader() {
        return new SAXReader();
    }
    
    public static DOMReader createDOMReader() {
        return new DOMReader();
    }
    
    public static Document read(InputStream is) {
        try {
            return createSAXReader().read(is);
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }
    
    public static Document read(File file) {
        try {
            return createSAXReader().read(file);
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }
    
    public static Document read(InputSource is) {
        try {
            return createSAXReader().read(is);
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }
    
    public static Document read(String xmlString) {
        return read(new InputSource(new StringReader(xmlString)));
    }
    
    public static Document read(URL url) {
        try {
			return createSAXReader().read(url);
		} catch (DocumentException e) {
			throw new RuntimeException(e);
		}
    }
    
    public static Document read(org.w3c.dom.Document doc) {
        return createDOMReader().read(doc);
    }
    
    
    /**
     * 解析xml到对象XmlMessage
     * @param document
     */
    public static XmlMessage parserXmlToSignMessage(Document document){
    	XmlMessage xmlMessage = new XmlMessage();
    	List<Book> array=new ArrayList<Book>();
    	if(document!=null){
    		String xmlText = document.asXML();
    		//System.out.println("xmlText:\r\n"+xmlText);
    	}
    	try {
    		Element root =document.getRootElement();
    		if(root.getName()!=null){//<transaction name="BuyBooks">
    			if(root.getName().trim().equals("transaction")){
    				//属性
					if(root.attribute("name")!=null){
						String attrValue=root.attribute("name").getText();//例如：BuyBooks
						xmlMessage.setTransaction(attrValue);
					}
    			}
    			
    		}
    		for(Iterator i = root.elementIterator(); i.hasNext();){   
    			Element element = (Element) i.next();
    			
    			if("header".equals(element.getName())){//遍历<header>
    				/*
<header>
		<title name="charset">UTF-8</title>
		<title name="system">MALL</title>
	</header>				 
    				 */
    				for(Iterator j = element.elementIterator(); j.hasNext();){   
    					Element node = (Element) j.next();
    					String tagName=node.getName();//例：title
    					String tagValue=node.getText();//例：UTF-8
    					//属性值获取
    					if(node.attribute("name")!=null){
    						String attrName=node.attribute("name").getName();//name
    						String attrValue=node.attribute("name").getText();//charset
    						//业务
    						if(attrValue.trim().equals("charset")){
    							xmlMessage.setCharset(tagValue);
    						}
    						if(attrValue.trim().equals("system")){
    							xmlMessage.setSystem(tagValue);
    						}
    					}
    					
    				}// end for
    				
    			}else if("body".equals(element.getName())){//遍历body
    				/*
<body>
...
</body>
    			 */
    			    				for(Iterator j2 = element.elementIterator(); j2.hasNext();){ 
    			    					/*
    	<field attr="word">Welcome</field>
		<field attr="people">all you guys</field>
    			    					 */
    			    					Element node2 = (Element) j2.next();
    			    					String tagName2=node2.getName();//例：field
    			    					String tagValue2=node2.getText();//例：Welcome
    			    					if(tagName2.trim().equals("field")){//field标签
    			    						//属性
        			    					if(node2.attribute("attr")!=null){
        			    						String attrName2=node2.attribute("attr").getName();//例：attr
        			    						String attrValue2=node2.attribute("attr").getText();//例：word
        			    						//业务
        			    						if(attrValue2.trim().equals("word")){
        			    							xmlMessage.setWord(tagValue2);
        			    						}
        			    						if(attrValue2.trim().equals("people")){
        			    							xmlMessage.setPeople(tagValue2);
        			    						}
        			    						
        			    					}// end if 属性
    			    					}else if(tagName2.trim().equals("array")){//<array>标签
    			    						
    			    						/*
    	<array>
		    <book key="bookId">100010</book>
		    <book key="bookName">唐诗300首</book>
		    <book key="bookPrice">21元</book>
		    <book key="bookQuantity">135本</book>
		</array>
    			    						 */
    			    						
    			    						Book book=new Book();
    			    						
    			    						for(Iterator j3 = node2.elementIterator(); j3.hasNext();){
    			    							Element node3 = (Element) j3.next();
    	    			    					String tagName3=node3.getName();//例：book
    	    			    					String tagValue3=node3.getText();//例：100010
    	    			    					
    	    			    					if(tagName3.trim().equals("book")){//book标签
    	    			    						//属性
    	        			    					if(node3.attribute("key")!=null){
    	        			    						String attrName3=node3.attribute("key").getName();//例：key
    	        			    						String attrValue3=node3.attribute("key").getText();//例：bookId
    	        			    						//业务
    	        			    						if(attrValue3.trim().equals("bookId")){
    	        			    							book.setBookId(tagValue3);
    	        			    						}
    	        			    						if(attrValue3.trim().equals("bookName")){
    	        			    							book.setBookName(tagValue3);
    	        			    						}
    	        			    						if(attrValue3.trim().equals("bookPrice")){
    	        			    							book.setBookPrice(tagValue3);
    	        			    						}
    	        			    						if(attrValue3.trim().equals("bookQuantity")){
    	        			    							book.setBookQuantity(tagValue3);
    	        			    						}
    	        			    						
    	        			    					}// end if 属性
    	    			    					}
    			    						}
    			    						array.add(book);
    			    					}//end //array标签
    			    					
    			    					xmlMessage.setArray(array);
    			    				}//end for  //遍历body
    			    				
    			    			}
    		}
    	}catch (Exception e) {
    		e.printStackTrace();
    	}
    	return xmlMessage;
    }  
    
    /**
     * 生成xml字符串，使用StringBuffer
     * @param xmlMessage
     * @return
     */
    public static String createXmlByString(XmlMessage xmlMessage){
    	
    	StringBuffer buf=new StringBuffer("");;
        if(xmlMessage==null){
    		
    	}else{
    		buf.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
    		String transaction=(xmlMessage.getTransaction()==null)?"":xmlMessage.getTransaction().trim();
    		buf.append("<transaction name=\""+transaction+"\">");
    		buf.append("<header>");
    		String charset=(xmlMessage.getCharset()==null)?"":xmlMessage.getCharset().trim();
    		buf.append("<title name=\"charset\">"+charset+"</title>");
    		String system=(xmlMessage.getSystem()==null)?"":xmlMessage.getSystem().trim();
    		buf.append("<title name=\"system\">"+system+"</title>");
    		buf.append("</header>");
    		buf.append("<body>");
    		String word=(xmlMessage.getWord()==null)?"":xmlMessage.getWord().trim();
    		buf.append("<field attr=\"word\">"+word+"</field>");
    		String people=(xmlMessage.getPeople()==null)?"":xmlMessage.getPeople().trim();
    		buf.append("<field attr=\"people\">"+people+"</field>");
    		
    		if(xmlMessage.getArray()!=null){
    			List<Book> array=xmlMessage.getArray();
    			for(int i=0;i<array.size();i++){
    				Book bk=array.get(i);
    				buf.append("<array>");
    	    		
    				String bookId=(bk.getBookId()==null)?"":bk.getBookId().trim();
    	    		buf.append("<book key=\"bookId\">"+bookId+"</book>");
    	    		String bookName=(bk.getBookName()==null)?"":bk.getBookName().trim();
    	    		buf.append("<book key=\"bookName\">"+bookName+"</book>");
    	    		String bookPrice=(bk.getBookPrice()==null)?"":bk.getBookPrice().trim();
    	    		buf.append("<book key=\"bookPrice\">"+bookPrice+"</book>");
    	    		String bookQuantity=(bk.getBookQuantity()==null)?"":bk.getBookQuantity().trim();
    	    		buf.append("<book key=\"bookQuantity\">"+bookQuantity+"</book>");
    	    		
    				buf.append("</array>");
    			}
    		}//end if
    		
    		buf.append("</body>");
    		buf.append("</transaction>");
    		
    	}
    	
    	return buf.toString();
    }
    
    
    /**
     * 生成xml字符串，使用dom4j生成
     * @param xmlMessage
     * @return
     */
    public static String createXmlByDom4j(XmlMessage xmlMessage){
    	String xml="";
    	Document document = DocumentHelper.createDocument();
    	
        Element root = document.addElement("transaction");
        String transaction=(xmlMessage.getTransaction()==null)?"":xmlMessage.getTransaction().trim();
		root.addAttribute("name", transaction);
		
        Element element_header = root.addElement("header");
        
        //<title name="charset">gbk</title>
        Element element_title_charset = element_header.addElement("title");
        String charset=(xmlMessage.getCharset()==null)?"":xmlMessage.getCharset().trim();
        element_title_charset.addAttribute("name","charset");
        element_title_charset.addText(charset);
        
        //<title name="system">MALL</title>
        Element element_title_system = element_header.addElement("title");
        String system=(xmlMessage.getSystem()==null)?"":xmlMessage.getSystem().trim();
        element_title_system.addAttribute("name","system");
        element_title_system.addText(system);
        
        //<body>
        Element element_body = root.addElement("body");
        
        //<field attr="word">Welcome</field>
        Element element_field_word = element_body.addElement("field");
        String word=(xmlMessage.getWord()==null)?"":xmlMessage.getWord().trim();
        element_field_word.addAttribute("attr","word");
        element_field_word.addText(word);
        
        //<field attr="people">all you guys</field>
        Element element_field_people = element_body.addElement("field");
        String people=(xmlMessage.getPeople()==null)?"":xmlMessage.getPeople().trim();
        element_field_people.addAttribute("attr","people");
        element_field_people.addText(people);
        
//        <array>
//	    <book key="bookId">100010</book>
//	    <book key="bookName">唐诗300首</book>
//	    <book key="bookPrice">21元</book>
//	    <book key="bookQuantity">135本</book>
//	</array>
        if(xmlMessage.getArray()!=null){
			List<Book> array=xmlMessage.getArray();
			for(int i=0;i<array.size();i++){
				Book bk=array.get(i);
				//<array>
		        Element element_array = element_body.addElement("array");
		        
		        //<book key="bookId">100010</book>
		        Element element_array_bookId = element_array.addElement("book");
		        String bookId=(bk.getBookId()==null)?"":bk.getBookId().trim();
		        element_array_bookId.addAttribute("key","bookId");
		        element_array_bookId.addText(bookId);
		        
		        //<book key="bookName">唐诗300首</book>
		        Element element_array_bookName = element_array.addElement("book");
		        String bookName=(bk.getBookName()==null)?"":bk.getBookName().trim();
		        element_array_bookName.addAttribute("key","bookName");
		        element_array_bookName.addText(bookName);
		        
		        //<book key="bookPrice">21元</book>
		        Element element_array_bookPrice = element_array.addElement("book");
		        String bookPrice=(bk.getBookPrice()==null)?"":bk.getBookPrice().trim();
		        element_array_bookPrice.addAttribute("key","bookPrice");
		        element_array_bookPrice.addText(bookPrice);
		        
		        //<book key="bookQuantity">135本</book>
		        Element element_array_bookQuantity = element_array.addElement("book");
		        String bookQuantity=(bk.getBookQuantity()==null)?"":bk.getBookQuantity().trim();
		        element_array_bookQuantity.addAttribute("key","bookQuantity");
		        element_array_bookQuantity.addText(bookQuantity);
		        
			}
		}//end if
        xml=document.asXML();//生成字符串
    	
    	return xml;
    }
    public static void main(String[] args){
    	//解析功能
    	//测试1，解析xml，结果放入一个对象中
//    	File file=new File(Dom4jXmlUtil.class.getClassLoader().getResource("org/xml/file/XmlMessage.xml").getPath());
//    	System.out.println("filepath:"+file.getPath());
//    	
//    	Document document=Dom4jXmlUtil.read(file);
//    	XmlMessage xmlMessage=Dom4jXmlUtil.parserXmlToSignMessage(document);
//    	if(xmlMessage!=null){
//    		System.out.println("json_xmlMessage:\r\n"+JsonUtil.objectToJson(xmlMessage));
//    		
//    	}
    	
    	
    	//生成功能
    	//测试2，使用生成xml字符串，使用StringBuffer
//    	XmlMessage obj=VelocityUtil.getOneXmlMessage();//生成一个对象，并赋值,供测试使用
//    	String resXml=Dom4jXmlUtil.createXmlByString(obj);
//    	System.out.println(resXml);
    	
    	//测试3，生成xml字符串，使用dom4j生成
    	XmlMessage obj2=VelocityUtil.getOneXmlMessage();//生成一个对象，并赋值,供测试使用
    	String resXmlDom4j=Dom4jXmlUtil.createXmlByDom4j(obj2);
    	System.out.println("resXmlDom4j:\r\n"+resXmlDom4j);
    }
}


/*
 测试1打印;
filepath:D:\ChinaDevelopmentBankJBPM\workSpace\frame\webapp\WEB-INF\classes\org\xml\file\XmlMessage.xml
json_xmlMessage:
{"array":[{"bookId":"100010","bookName":"唐诗300首","bookPrice":"21元","bookQuantity":"135本"},{"bookId":"100012","bookName":"宋词","bookPrice":"15元","bookQuantity":"121本"}],"charset":"UTF-8","people":"all you guys","system":"MALL","transaction":"BuyBooks","word":"Welcome"}
把json美化后看看结构和数据字段是不是对应：
  
{
  "array":[
           {"bookId":"100010","bookName":"唐诗300首","bookPrice":"21元","bookQuantity":"135本"},
           {"bookId":"100012","bookName":"宋词","bookPrice":"15元","bookQuantity":"121本"}
	  ],
  "charset":"UTF-8",
  "people":"all you guys",
  "system":"MALL",
  "transaction":"BuyBooks",
  "word":"Welcome"
}

//测试2打印
  <?xml version="1.0" encoding="UTF-8"?><transaction name="查询"><header><title name="charset">gbk</title><title name="system">taobao</title></header><body><field attr="word">hello</field><field attr="people">张三</field><array><book key="bookId">11</book><book key="bookName">三国演义</book><book key="bookPrice">50元</book><book key="bookQuantity">0</book></array><array><book key="bookId">22</book><book key="bookName">西游记</book><book key="bookPrice">55元</book><book key="bookQuantity">10</book></array></body></transaction>



测试3打印;
resXmlDom4j:
<?xml version="1.0" encoding="UTF-8"?>
<transaction name="查询"><header><title name="charset">gbk</title><title name="system">taobao</title></header><body><field attr="word">hello</field><field attr="people">张三</field><array><book key="bookId">11</book><book key="bookName">三国演义</book><book key="bookPrice">50元</book><book key="bookQuantity">0</book></array><array><book key="bookId">22</book><book key="bookName">西游记</book><book key="bookPrice">55元</book><book key="bookQuantity">10</book></array></body></transaction>

*/

对于上面我已经把打印结果页写上去了。

里面需要有个类VelocityUtil

package org.xml.util;

import java.io.File;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.dom4j.Document;
import org.xml.bean.Book;
import org.xml.bean.XmlMessage;

public class VelocityUtil {
	
	/**
	 * 生成xml字符串，使用Velocity模板
	 * @param xmlMessage
	 * @param file_resource_loader_path
	 * @param templateFile
	 * @return
	 */
	public String getXmlFromVmByVelocity(XmlMessage xmlMessage,String file_resource_loader_path,String templateFile) {
		String resultXml="";
		try {
			//引擎设置
			Properties prop = new Properties(); 
		    prop.setProperty(Velocity.INPUT_ENCODING, "UTF-8");  //设置输入输出编码类型
		    prop.setProperty(Velocity.OUTPUT_ENCODING, "UTF-8"); 
		    //指定一个绝对路径作为模版路径.例如  D:/MyProject/my-workSpace/Mytest/bin/org/test
		    prop.setProperty(Velocity.FILE_RESOURCE_LOADER_PATH, file_resource_loader_path);
			VelocityEngine velocityEngine = new VelocityEngine();
			velocityEngine.init(prop);
			
			System.out.println("模板路径--"+velocityEngine.getProperty(Velocity.FILE_RESOURCE_LOADER_PATH));
			
			VelocityContext context = new VelocityContext();
			context.put("xmlMessage", xmlMessage);//放入对象
			
			//如果有其他的属性，也可以取出来直接放进去，这和session取值放值类似
//			if(xmlMessage.getArray()!=null){
//				context.put("array", xmlMessage.getArray());
//			}
			Template template = null;//模版
			try {
				template = velocityEngine.getTemplate(templateFile,"UTF-8");//非单例。注意设置编码，避免中文乱码
			} catch (ResourceNotFoundException e1) {
				System.out.println("Velocity error,ResourceNotFoundException:"
						+ templateFile);
			} catch (ParseErrorException e2) {
				System.out.println("Velocity error,ParseErrorException:"
						+ templateFile + ":" + e2);
			}
			StringWriter strWirter=new StringWriter();
			
			if (template != null){
				template.merge(context, strWirter);//解析
				resultXml=strWirter.getBuffer().toString();//生成结果返回
			}
		} catch (Exception e) {
			System.out.println(e);
		}
		
		return resultXml;
	}
	
	public static XmlMessage getOneXmlMessage(){

    	XmlMessage xml=new XmlMessage();
    	xml.setCharset("gbk");
    	xml.setPeople("张三");
    	xml.setSystem("taobao");
    	xml.setTransaction("查询");
    	xml.setWord("hello");
    	
    	List<Book> array=new ArrayList<Book>();
    	Book bk1=new Book();
    	Book bk2=new Book();
    	bk1.setBookId("11");
    	bk1.setBookName("三国演义");
    	bk1.setBookPrice("50元");
    	bk1.setBookQuantity("0");

    	bk2.setBookId("22");
    	bk2.setBookName("西游记");
    	bk2.setBookPrice("55元");
    	bk2.setBookQuantity("10");
    	
    	array.add(bk1);
    	array.add(bk2);
    	
    	xml.setArray(array);
    	
    	return xml;
    	
	}
	public static void main(String[] args) {
		//生成功能
		VelocityUtil v2 = new VelocityUtil();

		String basepath=VelocityUtil.class.getClassLoader().getResource("").getPath();
		System.out.println(basepath);
		
    	XmlMessage xml=getOneXmlMessage();
    	
		String res=v2.getXmlFromVmByVelocity(xml,basepath, "org/xml/file/XmlMessage.vm");
		System.out.println("haha,成功\r\n"+res);
    	
	}
}


/*打印：

/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/
模板路径--/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/
haha,成功
<?xml version="1.0" encoding="UTF-8"?>
<transaction name="查询">
	<header>
		<title name="charset">gbk</title>
		<title name="system">taobao</title>
	</header>
	<body>
		<field attr="word">hello</field>
		<field attr="people">张三</field>
		<array>          
	            <book key="bookId">11</book>
	            <book key="bookName">三国演义</book>
	            <book key="bookPrice">50元</book>
	            <book key="bookQuantity">0</book>
		</array>
		<array>          
	            <book key="bookId">22</book>
	            <book key="bookName">西游记</book>
	            <book key="bookPrice">55元</book>
	            <book key="bookQuantity">10</book>
		</array>
			</body>
</transaction>



 */

VelocityUtil需要一个文件XmlMessage.vm

<?xml version="1.0" encoding="UTF-8"?>
<transaction name="$!xmlMessage.getTransaction()">
	<header>
		<title name="charset">$!xmlMessage.getCharset()</title>
		<title name="system">$!xmlMessage.getSystem()</title>
	</header>
	<body>
		<field attr="word">$!xmlMessage.getWord()</field>
		<field attr="people">$!xmlMessage.getPeople()</field>
		#foreach( $book in $xmlMessage.getArray() )
<array>          
	            <book key="bookId">$!book.getBookId()</book>
	            <book key="bookName">$!book.getBookName()</book>
	            <book key="bookPrice">$!book.getBookPrice()</book>
	            <book key="bookQuantity">$!book.getBookQuantity()</book>
		</array>
		#end
	</body>
</transaction>


一下把所有代码都给出了，现在开始讲解。

对于解析xml，我就不再细说了，dom4j就是把xml转化成一个Document，进行内容和属性的读取，只是对于api不熟悉的话，

慢慢尝试一下，就知道怎么取值的了。


对于生成想xml，我知道3中方法：

一，拼写字符串。就是把变量的属性经过判断最后拼装成一个完整的xml字符串。

二，使用Velocity生成。

对于Velocity是什么，怎么用我就不说了。

这个Veolicty有自己的一套解析模板语言（逻辑很简单），它解析vm格式的文件。

我们可以定义好模板vm，把需要填充的值都使用模板定义的语言定义好，Velocity会解析并填充。

最后把整个vm文件中的字符返回。这个思想就是模板的思想（和jsp类似道理）。

使用这个生成xml，好处就是我们只要定义好模板就可以了，并且模板可以多变，需求变化，我们只需要改模板就可以。

一个方法写好，可以定义多个模板，来是实现多种需求。如果使用第一种方法，就需要写很多if...else。。。判断语句了。

三，使用dom4j来生成xml。

这个很好理解了，dom4j生成就xml就好比画一棵树。它的结构清晰，从根节点一点点往下加节点就可以。

只是这个逻辑也需要很多判断，代码比第一种方法显得稍笨拙一些。大多数人很熟悉字符串操作，所以大多数人

都是用第一种方法。










分享到：
| oracle复制一张表（表结构和数据），2张表 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    用xml与java创建程序生成器

    我们可以使用如JDOM、DOM4J或者Java内置的DOM、SAX、StAX等API来解析XML。在解析完成后，Java代码可以通过字符串操作或者模板引擎（如FreeMarker、Velocity等）生成目标代码。 下面是一个简化的步骤概述： 1. **...

    java生成指定格式的XML

    DOM4J是一个流行的Java库，提供了更高级别的API来处理XML，它支持DOM、SAX和STAX，功能强大且易于使用。 6. **XMLWriter和XMLStreamWriter** `java.xml.transform.stream.XMLStreamWriter`是Java标准库中的一个类...

    解析excel、xml配置文件&&输出java测试文件Demo

    - 基于解析的Excel和XML数据，我们可以使用Java I/O和模板引擎（如FreeMarker或Velocity）生成Java测试代码。 - 创建模板文件，其中包含占位符，用解析到的数据替换这些占位符生成最终的Java文件。 - 示例代码...

    java 通过模板生成 xml

    1. **DOM解析器**：DOM将整个XML文档加载到内存中，创建一个树形结构，允许程序遍历和修改XML节点。在使用模板时，你可以预先定义一个XML结构作为模板，然后使用DOM API填充数据。例如： ```java ...

    xml读写

    1. **DOM方式**：创建`Document`对象，添加元素和属性，然后使用`Transformer`将其转换为XML字符串或写入文件。 2. **XMLStreamWriter**：StAX提供API，允许按需写出元素，适合生成大型XML文档。 3. **模板引擎**：...

    XML資源說明XML資源說明

    - 模板引擎：`velocity.properties`和`.vm`文件表明可能使用了Velocity模板引擎，它允许用XML模板来动态生成HTML或其他文本。 - 样式表：CSS（Cascading Style Sheets）用于控制网页布局，`cssHorizontalMenu.vm`...

    Xml做数据源模板显示新闻的源码.rar

    在Java中，可以使用DOM（Document Object Model）、SAX（Simple API for XML）或StAX（Streaming API for XML）等API来解析XML。DOM一次性加载整个XML文档到内存，适合小型XML文件；SAX是事件驱动的，只读且占用资源...

    velocity语法 velovity包

    3. **dom4j-1.1.jar**：DOM4J是一个流行的XML处理库，Velocity在处理XML文档时可能需要它。 4. **struts-core-1.3.8.jar** 和 **struts-taglib-1.3.8.jar**：这两个是Struts框架的核心库，Velocity常与Struts结合...

    struts2 jquery xml

    Struts2 jQuery XML 是一个基于Java的Web开发框架的组合，它将Apache Struts2的MVC架构与jQuery库结合，提供了丰富的用户界面组件和更流畅的AJAX交互。Struts2是一个强大的、灵活的MVC框架，而jQuery则简化了...

    velocity Java开发指南中文版

    - **参考资源**: 在使用Velocity时，开发者需要了解其依赖的库，例如Apache Commons Logging，用于日志记录，以及可能的模板解析库，如JDOM或DOM4J，用于处理XML结构的模板。 - **它是如何工作的？**: Velocity...

    NVelocity入门，为服务器与客户端传输xml数据，实现Ajax通信铺平道路

    在C#中，你可以使用`System.Xml.Linq`库来创建和操作XML文档，然后将其传递给NVelocity进行渲染。 NVelocity和Ajax的结合使用有助于实现无刷新的用户界面，提高应用程序的交互性和用户体验。通过合理的数据模型设计...

    java生成XML的方法【附demo源码下载】

    在Java编程中，生成XML文件是一项常见的任务，用于数据存储、配置传递或者数据交换等...提供的代码示例展示了如何结合MyBatis和DOM操作XML，但为了更好地适应大型项目，建议使用更高级的API和模板引擎来处理XML生成。

    JSP and XML

    4. **结构化数据**：XML文档必须有严格的结构，便于解析和验证。 5. **DTD（Document Type Definition）或XSD（XML Schema Definition）**：用于定义XML文档的结构和数据类型，确保数据的有效性和一致性。 **JSP和...

    Springmvc+mybatis+velocity+easyui+jquery框架

    MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录。 【Velocity】 Velocity是Apache软件基金会的一个开源项目，它是一个Java...

    报表自定义菜单设计五大步骤之XML文档

    在实际开发中，为了提高可维护性和复用性，我们可能还会考虑使用模板引擎，如FreeMarker或Velocity，来动态生成XML文档，或者使用XSLT进行XML转换，以适应不同的展示需求。 总结起来，报表自定义菜单设计通过XML...

    用Velocity改装的jquery+json+springMVC+ibatis简单例子

    3. **JSON（JavaScript Object Notation）**：JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在本项目中，服务器端SpringMVC和iBatis处理的数据将以JSON格式返回给客户端的jQuery，...

    java开发常用jar包

    Hibernate使用dom4j解析XML配置文件和XML映射元文件。必需的。 ehcache-1.2.jar Hibernate可以使用不同cache缓存工具作为二级缓存。EHCache是缺省的cache缓存工具。如果没有其它的可选缓存工具，则为必需的。 ...

    本地仓库的第二部分

    6. **wsdl4j**：WSDL4J是一个开源的WSDL（Web服务描述语言）处理库，用于读取、写入和操作WSDL文件，是开发Web服务的重要工具。 7. **xpp3**：XPP3（XML Pull Parser for Java, version 3）是一个高效的XML解析器，...

    .m2 jar 库文件 第二部分 共 2部分

    5. **wsdl4j**: WSDL4J是一个用于处理WSDL（Web Services Description Language）文档的Java库，用于描述Web服务及其接口。 6. **plexus**: Plexus是Apache Maven的一个组件框架，提供了一种方式来构建复杂的软件...

    JAVA社区交流平台网站

    2.2.2 Dom4j 6 2.2.3 SOAP 6 2.2.4 WebService 7 2.2.5 WSDL 7 2.2.6 Velocity 8 2.2.7 Swing 8 2.2.8 Java反射 9 2.3 本章小结 9 第三章 服务开发平台的总体框架 10 3.1 前台可视化IDE的设计 11 3.2 后台的总体设计...

Magicbox
Global site tag (gtag.js) - Google Analytics