java工具类之Json，Xml格式转化

在项目开发的过程中经常会使用一些工具类，但是经常有这样的习惯A项目的工具类，B项目也要用。解决的办法很多，直接拷过去，或者单独搞一个基础工具类项目，或者把工具类打包！！！。于是我就开始收集有一些常用的Javag工具类。

今天先发布两个，一个Json和对象的相互转化，一个XML的。

不多说上代码。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * XML与对象转化
 *
 * @author 疾风
 * 2016年10月14日
 */
public class BeanXmlUtil {
   
    private static final Logger logger = LoggerFactory.getLogger(BeanXmlUtil.class);
   
    /**
     * 将对象解析成XML
     */
    public static String format(Object obj, String charset) {
        ByteArrayOutputStream baos = null;
        try {
            JAXBContext ctx = JAXBContext.newInstance(obj.getClass());
            baos = new ByteArrayOutputStream();
           
            Marshaller m = ctx.createMarshaller();
            m.setProperty(Marshaller.JAXB_ENCODING, charset);
            m.marshal(obj, baos);
           
            String result = baos.toString();
            if (logger.isDebugEnabled()) {
                logger.debug(result);
            }
           
            return result;
           
        } catch (JAXBException e) {
            throw new IllegalStateException(e);
           
        } finally {
            try {
                if (baos != null) baos.close();
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }
        }
    }
   
    /**
     * 将XML解析成对象
     */
    public static Object parse(String xml, Class<?> clazz, String charset) {
        InputStreamReader reader = null;
        try{
            JAXBContext ctx = JAXBContext.newInstance(clazz);
            ByteArrayInputStream bis = new ByteArrayInputStream(xml.getBytes(charset));
           
            Unmarshaller um = ctx.createUnmarshaller();
           
            reader = new InputStreamReader(bis, charset);
            return um.unmarshal(reader);
           
        }catch (JAXBException e){
            throw new IllegalStateException(e);
           
        } catch (UnsupportedEncodingException e) {
            throw new IllegalStateException(e);
           
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }
        }       
    }
   
    /**
     * 将对象解析成XML
     */
    public static String formatUseGBK(Object obj) {
        return format(obj, "GBK");
    }
   
    /**
     * 将对象解析成XML
     */
    public static String formatUseUtf8(Object obj){
        return format(obj, "UTF-8");
    }

    /**
     * 将XML解析成对象
     */
    public static Object parseUTF8(String xml, Class<?> clazz){
        return parse(xml, clazz, "UTF-8");
    }

    /**
     * 将XML（GBK）解析成对象
     */
    public static Object parseGBK(String xml, Class<?> clazz){
        return parse(xml, clazz, "GBK");
    }
}

以上是XML格式的转化。

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;


/**
 * json与对象转化
 *
 * @author 疾风
 * 2016年10月15日
 */
public class JsonUtils {

    /**
     * 将json字符串转换成对象
     */
    public static Object parse(String json, Class<?> clazz) {
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new IllegalArgumentException("无法解析JSON对象", e);
        }
    }
   
    /**
     * 将java对象格式化为字符串
     */
    public static String format(Object obj) {
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            return objectMapper.writeValueAsString(obj);
        } catch (IOException e) {
            throw new IllegalArgumentException("格式化对象为JSON格式出错", e);
        }
    }

    /**
     * 将json字符串转换成JsonNode对象
     */
    public static JsonNode parse(String json) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readTree(json);
        } catch (IOException e) {
            throw new IllegalArgumentException("格式化对象为JSON格式出错", e);
        }
    }
   
    /**
     * 将json字符串转换成list
     */
    public static List<?> parseList(String json, Class<?> clazz) {
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            return objectMapper.readValue(json, objectMapper.getTypeFactory().constructParametricType(List.class, clazz));
        } catch (IOException e) {
            throw new IllegalArgumentException("无法解析JSON对象", e);
        }
    }
}

以上缺一个和Map格式的转化，本人写了一个结果失败了，就没贴出来，以后要是搞好了再贴上去。

其他的工具类我会慢慢整理出来。