`

java bean和xml相互转换

阅读更多

这几天在做微信公众号

做的过程中想找个java bean转xml的工具,找了几个用着不知道是配置不好还是怎么回事,都会有一些问题,

然后脑子一热谢了一个javabean和xml的转换的工具里,自己用着还行,虽然有一些约束吧 ,

还是贴出来记录一下 

 

 

顺便你提一下下,这个转换工具支持属性为集合、数组和非基本属性的对象。

 

package com.uke.util;

import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.xml.sax.InputSource;

import com.uke.bean.Message;
import com.uke.bean.remsg.Music;
import com.uke.bean.remsg.ReMusicMsg;

/**
 * 
 * @author q821424508@sina.com
 *
 */
public class BeanUtil {

	/**
	 * 对象转为xml字符串
	 * @param obj
	 * 需要转xml的对象
	 * @param root
	 * xml跟标签的名称,默认为xml
	 * @return
	 * 返回转换后的xml
	 * <br>
	 * 说明:
	 * <br>
	 * 目前来说这个方法能够把对象转换成xml字符串没有什么问题,但是对bean类有一定的要求:
	 * <br>
	 * 1.<strong>bean类的没有需要设置的属性必须有getter、setter方法</strong>
	 * 2.<strong>生成的xml不会设置到xml的属性</strong>
	 * @throws InstantiationException 
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 * @throws JDOMException
	 * @throws IOException
	 * @throws ParserConfigurationException
	 */
	public static String convertToXml(Object obj,String root) throws InstantiationException  {
		
		//加这一句判断是为了方便递归调用,如果root为空,那么视为第一次调用,也就是xml的根
		if(StrUtil.isNullOrEmptyOrBlank(root)){
			root = "xml";
		}
		if(root.equalsIgnoreCase("item")){
			////、!!为什么只有这个以的item的i是小写的,其他的标签都是第一个字符大写的。why
			root = root.toLowerCase();
		}
			
		
		try {
		//声明一个列表 存放需要转换成xml类的所有设计的父类
		//这个地方没有涉及到属性为类的地方,应为下面的处理方法是,如果属性是类的话,就递归调用这个方法,所以没有什么需要担心的
		List<Class<?>> cl = new ArrayList<Class<?>>();
		
		//获取对象的类
		Class<?> clazz = obj.getClass();
		
		//判断,如果父类不是Object的话把所有的类放到上面声明的list里面 
		String simpleName = clazz.getSimpleName();
		
		while (!"Object".equals(simpleName)) {
			cl.add(clazz);
			clazz = clazz.getSuperclass();
			simpleName = clazz.getSimpleName();
		}
		//上面是从子类开始存放的,所以这里要反转
		Collections.reverse(cl);
		
		
		
		//开始创建xml
		StringBuffer xml = new StringBuffer("<"+root+">\n");
		
		for (Class<?> cz : cl) {
			//System.out.println("list  " + cz.getName());
			//获取类里面声明的所有属性,之所以上面要获取父级的类,时应为这里只能获取当前类的声明方法,无法获取到集成来的方法
			Field[] fs = cz.getDeclaredFields();
			for (Field f : fs) {
				
//				System.out.println("f.getName() = "+f.getName());
//				System.out.println("f.getName() = "+f.getType().getName());
//				
				//获取属性的类型
				Class<?> ct =f.getType();
				//获取类对应的名称
				String ctName = ct.getSimpleName();
				String fName = f.getName();
				String firstUpperName = fName.substring(0, 1).toUpperCase()+fName.substring(1);
				
				
				
				//System.out.println();
				//当然,如果类是基础类型的直接设值就可以了
				if("int".equals(ctName) || "long".equals(ctName)|| "double".equals(ctName)|| "float".equals(ctName) || "char".equals(ctName)){
					xml.append(getFieldXml(f,cz,obj)).append("\n");
				}else if("String".equals(ctName)||"char".equals(ctName)){
					xml.append(getFieldXml(f,cz,obj)).append("\n");
				}else {
					
					//如果属性不是基础类型的,则需要递归调用,也就是把上面的方法冲走一遍
					//通过执行get方法,获取对象的返回值。
					String methodName = "get" +firstUpperName;
					Class<?>[] cnull = null;
					Method m=cz.getMethod(methodName, cnull);
					Object[] osnull =null;
					Object reto=m.invoke(obj, osnull);
					
					
					if(null!=reto){
					
						if(reto instanceof Collection<?>){
							//如果结果是集合类型,那么获取子元素继续
							
							xml.append("<"+firstUpperName+">\n");
							Collection<Object> ol = (Collection<Object>)reto;
							for(Object o:ol){
								xml.append(convertToXml(o,o.getClass().getSimpleName()));
							}
							
							xml.append("</"+firstUpperName+">\n");
						}else if(reto instanceof Array){
							//如果结果是数组类型,那么获取数组里每个元素继续
							xml.append("<"+firstUpperName+">\n");
							Object[] ol = (Object[])reto;
							for(Object o:ol){
								xml.append(convertToXml(o,o.getClass().getSimpleName()));
							}
							
							xml.append("</"+firstUpperName+">\n");
						} else{
							//如果返回值不为null 执行递归调用
							xml.append(convertToXml(reto,ctName));
						}
					}else{
						//如果为null,直接在这个属性里面设置为空就可以了
						xml.append("<"+firstUpperName+">\n</"+firstUpperName+">\n");
					}
				}
			}
			
		}
		xml.append("</"+root+">\n");
		
		return xml.toString();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		} 
		return null;
	}

	/**
	 * 通过Filed,Class,和Objec对象获取需要生成的对应Filed的字符串
	 * @param f
	 * @param cz
	 * @param obj
	 * @return
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 */
	private static String getFieldXml(Field f, Class<?> cz, Object obj) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		String fName = f.getName();
		
		String firstUpperName = fName.substring(0, 1).toUpperCase()+fName.substring(1);
		String str = "<"+firstUpperName+">";
		
		String methodName = "get" +firstUpperName;
		
		
		Class<?>[] cnull = null;
		Method m=cz.getMethod(methodName, cnull);
		Object[] osnull =null;
		Object reto=m.invoke(obj, osnull);
		if(null!=reto){
			
			Class<?> ct =f.getType();
			String ctName = ct.getSimpleName();
			if("int".equals(ctName) || "long".equals(ctName)){
				if("0".equals(reto.toString())){
					System.err.println(fName +" 对应的值为0");
				}
				str +=reto.toString();
			}else if("double".equals(ctName)|| "float".equals(ctName)){
				if("0.0".equals(reto.toString())||"0".equals(reto.toString())){
					System.err.println(fName +" 对应的值为0");
				}
				str +=reto.toString();
			}else{
				str +="<![CDATA["+reto.toString()+"]]>";
			}
		}else{
			System.err.println(fName +" 对应的值为空");
		}
		str +="</"+firstUpperName+">";
		return str;
	}
	
	/**
	 * 通过xml字符串转换成给定类的对象
	 * @param xml
	 * 需要转成对象的字符串
	 * @param c
	 * 返回对象的类[Class]
	 * @return
	 * 返回对象的实例
	 * <br>
	 * 1.转换过程中不会操作任何xml的属性操作,值是一个标签对应一个属性来操作的
	 * <br>
	 * 2.参数Class<?> c对应的类,需要设置的属性都必须有getter,setter方法
	 */
	public static <T> T converyToJavaBean(String xml, Class<T> c) {
		T t = null;
		try {
			t= c.newInstance();
			SAXBuilder sb = new SAXBuilder();
			StringReader read = new StringReader(xml);
		    InputSource source = new InputSource(read);
			Document doc = sb.build(source);
			Element root =doc.getRootElement();
			convery(root,c,t);
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}

		return t;
	}

	private static void convery(Element e,Class<?> clazz,Object o) throws SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException{
//		System.out.println("el.size = "+el.size());
//		String text = e.getTextTrim();
//		System.out.println("text = "+text);
		
		String en =e.getName();
		if("xml".equals(en)){
			List<Element> el = e.getChildren();
			for(Element e1:el){
				convery(e1,clazz,o);
			}
		}else{
			List<Element> el = e.getChildren();
			if(el.size()>0){
				String childClassName =e.getName();
				
				String methodName = "get" +childClassName.substring(0, 1).toUpperCase()+childClassName.substring(1);
				
				Class<?> clazz1 = null;
				Method[] ms = clazz.getMethods();
				for(Method m:ms){
//					System.out.println(m.getName());
					if(methodName.equals(m.getName())){
						clazz1 = m.getReturnType();
					}
				}
//				try {
//					clazz1 = Class.forName(ncn);
//				} catch (Exception e2) {
//					System.err.println(ncn + " 实例化失败,请检查是否存在这个类 ");
//				}
				if(null==clazz1){
					//没有找到对应的类,这里只是忽略
					System.out.println(methodName + " 方法未找到,或者返回类型不正确 ");
					return;
				}
				Object o1 = clazz1.newInstance();
				
				try {
					//反射获取set方法,帮o1的值设置进o里面
					Method m =clazz.getMethod(methodName, clazz1);
					m.invoke(o, o1);
				} catch (Exception e2) {
					//应该是没有找到对应的方法,忽略
					System.err.println(methodName +" 方法调用失败,请检查方法是否存在");
					return ;
				}
				
				for(Element e1:el){
					convery(e1,clazz1,o1);
				}
			}else{
				String eName = e.getName();
				String methodName = "set" +eName.substring(0, 1).toUpperCase()+eName.substring(1);
				Method[] ms=clazz.getMethods();
				for(Method m:ms){
					if(m.getName().equals(methodName)){
						Class<?>[] c= m.getParameterTypes();
						//目前只支持带一个参数的情况
						String text = e.getTextTrim();
						Object v = null;
						String cn = c[0].getSimpleName();
						
						if("int".equals(cn)){
							v = Integer.parseInt(text);
						}else if("long".equals(cn)){
							v= Long.parseLong(text);
						}else if("double".equals(cn)){
							v = Double.parseDouble(text);
						}else if("float".equals(cn)){
							v = Float.parseFloat(text);
						}else{
							v = text;
						}
						m.invoke(o,v);
					}
				}
			}
		}
	}
	public static void main(String[] args) throws NoSuchMethodException,
			SecurityException, IllegalAccessException,
			IllegalArgumentException, InvocationTargetException, JDOMException,
			IOException, ParserConfigurationException, InstantiationException {
		ReMusicMsg rmm = new ReMusicMsg();
		Music m = new Music();
		m.setTitle("小苹果");
		m.setDescription("小苹果");
		m.setMusicUrl("http://yinyueshiting.baidu.com/data2/music/122112390/12012502946800128.mp3?xcode=b7d19aa0a1f43850273d9292ca2357ec3f8882ee658cd7de");
		m.setHQMusicUrl("http://yinyueshiting.baidu.com/data2/music/122112390/12012502946800128.mp3?xcode=b7d19aa0a1f43850273d9292ca2357ec3f8882ee658cd7de");
		rmm.setMusic(m);
		rmm.setMsgType("music");
		rmm.setCreateTime((int)(System.currentTimeMillis()/1000));
		rmm.setFromUserName("gh_32a91b043d76");
		rmm.setToUserName("os6Z4swOSB6pzVDtA90g0Fq4Dz_4");
		rmm.setFuncFlag(1);
		rmm.setMsgId(6051426418514665443l);
		rmm.setMsgType("music");
		
		String xml =convertToXml(rmm,null);
		
		System.out.println(xml);
		
		
		xml = "<xml><ToUserName><![CDATA[gh_32a91b043d76]]></ToUserName>/n<FromUserName><![CDATA[os6Z4swOSB6pzVDtA90g0Fq4Dz_4]]></FromUserName>/n<CreateTime>1409041861</CreateTime>/n<MsgType><![CDATA[text]]></MsgType>/n<Content><![CDATA[哈哈]]></Content>/n<MsgId>6051788711890992105</MsgId>/n</xml>/n";
		xml =xml.replaceAll(">/n", ">");
		System.out.println(xml);
		Message ms = converyToJavaBean(xml, Message.class);
		System.out.println(ms.getMsgType());
		
	}

}

 

使用和约束什么的,在方法头部已经写出来了,这里就不多说了,

如果你想测试的话,可能需要一下jar和一些自定义的类,

自定义的类你可以更具用到的属性直接写一个就行了,就是简单的属性和getter setter方法 

 

jar包应该只要jdom的就可以了 

已添加附件 

 

分享到:
评论

相关推荐

    xml 转Java bean工具

    在Java编程中,我们经常需要将XML数据转换为Java对象,也就是所谓的Java Bean,以便于处理和操作。Java Bean是符合一定规范的Java类,通常具有getter和setter方法,用于封装数据。 XML到Java Bean的转换可以手动...

    xml和java bean互相转换工具包(简单易用)

    xml 与 bean 互相转换 工具类 1、bean类的属性需要遵守BEAN规范,否则 无法 读存BEAN值。 2、bean类的属性如果 是集合 只支持数组以及List、Map、Set。 3、bean类属性(boolean除外)前面两个字母要么全部小写,要么...

    xml和bean 互相转换

    在Java开发中,XML(可扩展标记语言)和Bean之间的互相转换是一项常见的任务,尤其是在处理配置文件、数据交换或者序列化场景中。本篇将详细阐述XML与Bean之间的转换过程,以及相关的Java技术。 首先,XML是一种...

    将对象(java bean)转换为xml字符串

    XStream不仅能够将Java对象转换为XML,还可以反向将XML转换回Java对象,极大地简化了对象与XML之间的序列化和反序列化过程。 XStream库是由Johannes Lehtinen创建的一个开源项目,它是基于Java的,可以处理复杂的...

    java 使用 JAXB 将xml转换为 bean 包含xml和dto和读取文件的util类

    总结来说,这个压缩包提供的内容涉及了Java中使用JAXB进行XML与Java对象之间转换的实际应用,以及辅助的DTO和文件读取工具。这些对于理解和实现XML数据处理的Java应用非常有帮助。开发者可以通过学习和使用这些示例...

    javabean和xml互相转换工具类以及jar包

    - **使用JAXB(Java Architecture for XML Binding)**:JAXB是Java标准API,可以自动将Java对象转换为XML和从XML反序列化为Java对象。只需为JavaBean添加适当的注解,然后使用JAXBContext和Marshaller进行转换。 ...

    JavaXml及Bean互转

    本篇将详细介绍两种常用的Java XML与Bean互转方法:XStream库和JAXB(Java Architecture for XML Binding)框架。 一、XStream库 1. **XStream简介**: XStream是一个用于Java的轻量级库,它提供了一种简单的API来...

    Java Bean与xml互相转换的方法分析

    主要介绍了Java Bean与xml互相转换的方法,结合实例形式分析了java bean与xml转换的原理与相关操作技巧,需要的朋友可以参考下

    java对象与xml的互相转换

    JAXB允许我们将Java类绑定到XML Schema,从而能够方便地在Java对象和XML文档之间进行转换。要使用JAXB,你需要定义一个Java类,该类的字段对应于XML元素,然后使用JAXB提供的API将该对象转换为XML。 以下是一个简单...

    castor样例xml to bean和bean to xml样例

    2. Bean到XML转换: 反之,如果你有一个Java对象并且希望将其转换为XML格式,Castor也能轻松实现。通过调用Castor提供的序列化方法,你可以将Java对象转换为XML字符串或直接写入XML文件。这样,Java对象的数据就以...

    使用Betwixt将XML转为JAVA Bean(内有JAR包)

    在Java开发中,数据对象(通常称为Bean)与XML之间的转换是常见的需求,尤其是在处理配置文件、序列化或网络通信时。Betwixt是一个Apache软件基金会提供的库,专门用于XML与Java对象之间的绑定,使得我们可以方便地...

    xml to bean or bean to xml

    在提供的文件`ClassToXml.java`和`CC.java`中,很可能是实现了XML到Bean或Bean到XML转换的示例代码。具体实现细节需要查看源代码才能理解。通常,这些类会包含对JAXB API的调用,如创建JAXBContext、Unmarshaller和...

    java使用commons-betwixt 实现bean与xml互转

    Java中的Apache Commons Betwixt库提供了一个简单的方法来映射Java Bean对象和XML文档之间的数据,使得在处理数据交换时能轻松地实现bean到XML的转换和XML到bean的反转换。本篇文章将深入探讨如何使用Commons ...

    JAXBContext测试Java对象与xml的相互转换Demo

    在这个"JAXBContext测试Java对象与xml的相互转换Demo"中,我们将深入探讨如何利用JAXBContext实现这一功能。 首先,我们需要定义一个Java类,这个类将被映射为XML文档的元素。例如,我们可以创建一个`Person`类,...

    使用jaxb将XML转化为JAVA BEAN

    当一个Java对象被转换为XML时,JAXB会根据对象的属性和注解生成相应的XML元素和属性。例如,一个名为`Person`的类,包含`name`和`age`属性,可以通过以下方式标注: ```java @XmlRootElement(name = "person") ...

    xml和bean之间的相互转换源码

    在Java开发中,XML(可扩展标记语言)和Bean之间的相互转换是常见的操作,尤其是在处理配置文件、数据持久化或Web服务时。这里的"bean"通常指的是JavaBeans,即符合特定设计模式的Java对象,它们封装了数据并提供了...

    java-xml自动生成对象实体以及与xml相互转化.zip_Java doc转xml_java xml 转 实体_java 毕

    压缩包中的`trang.jar`可能是一个用于XML转换的工具,而`java中对象与xml相互转换.doc`可能是关于如何在Java中实现对象和XML之间转换的详细文档,涵盖了上述的一些技术点。 总之,Java XML处理技术是开发者必须掌握...

    xml文件自动转成java对象工具

    5. **生成序列化和反序列化代码**:为了方便XML数据和Java对象之间的转换,工具还会生成解析XML和生成XML的代码,通常是基于JAXB(Java Architecture for XML Binding)或其他类似库。 除了XSD转Java,有些工具还...

    cn.rar_java xml to bea_java commonUt_xml to be_xml to bean

    在IT行业中,XML(eXtensible Markup Language)与Java Bean之间的转换是一个常见的需求,特别是在数据持久化、网络通信和配置文件处理等场景。本文将深入探讨如何利用Java技术实现XML到Bean以及Bean到XML的双向解析...

    Converter between XML and Java Bean

    总之,"Converter between XML and Java Bean"涉及的关键知识点是利用如XStream这样的库实现XML与Java对象之间的转换,这在Java开发中是非常重要且实用的技能,尤其在处理数据交换、持久化存储和跨系统通信时。...

Global site tag (gtag.js) - Google Analytics