精华内容
下载资源
问答
  • 1.pom.xml com.alibaba fastjson 1.2.58 2.对象与字符串之间的互转 //将对象转换成为字符串 String UserDoStr = JSON.toJSONString(userDo); //字符串转换成为对象 UserDo userDo = JSON.parseObject...
  • Javastring类型的xml对象

    千次阅读 2019-11-22 15:06:22
    string类型的xml对象 string类型的xml结果如截图 现在要将IP_VALUE转化为实体。 上代码。 String result = "<NewDataSet><Table><IP_VALUE>0.125447616</IP_VALUE></Table>...

    将string类型的xml转对象

    string类型的xml结果如截图
    图一
    现在要将IP_VALUE转化为实体类。
    上代码。

    			String result = "<NewDataSet><Table><IP_VALUE>0.125447616</IP_VALUE></Table></NewDataSet>";
    			JSONObject object = XML.toJSONObject(result);
    			String jsonData = object.toString();
    			String jsonObject = jsonData.substring(jsonData.indexOf(":")+1, jsonData.length()-1);
    			String jsonObject2 = jsonObject.substring(jsonObject.indexOf(":")+1, jsonObject.length()-1);
    			Gson gson = new Gson();
    			RTDBDataModel rtdbDataModel = gson.fromJson(jsonObject2, RTDBDataModel.class);
    			return rtdbDataModel.getIP_VALUE();
    

    上图的result type String,value为图一。
    所需pom jar包。

    		<dependency>
                <groupId>org.json</groupId>
                <artifactId>json</artifactId>
                <version>20160810</version>
            </dependency>
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>2.8.5</version>
            </dependency>
    
    展开全文
  • 将字符串类型的字符串转换成的Java对象时,需要先将字符的格式转换成JSON格式的字符串(所以用到了json.jar包),在使用JSON格式的字符串转换成的Java对象类型   字符串原类型(XML格式): 将字符串类型...

    使用到的包:

    1。

    2。

    将字符串类型的字符串转换成的Java的对象时,需要先将字符的格式转换成JSON格式的字符串(所以用到了json.jar包),在使用JSON格式的字符串转换成的Java的对象类型

     

    字符串原类型(XML格式):

    将字符串类型的字符串转换成JSON格式的字符串:

    截取(ps:如果不截取{}中的内容的话,转换对象的时候,对象的属性将不会是json格式字符串中的值,而是实体类中的默认值)

    将JSON格式的字符串转换成的Java的对象类型

    代码如下:

    		//String类型的数据(原格式为XML格式)
    		String data = getXmlData(request);
    		System.out.println(data);
    
            //将String类型转换成json类型
    		 JSONObject object = XML.toJSONObject(data);
    		 String jsonData = object.toString();		//因为gson.formJson(String,class)
    		 System.out.println(jsonData);
            
            //截取字符串
            String jsonObject = jsonData.subString(jsonData.indexOf(":")+1, jsonData.length()-1)
    
            //将json格式的字符串转换成CertApplyRequest格式
    		Gson gson = new Gson();
    		CertApplyRequest Request = gson.fromJson(jsonObject, CertApplyRequest.class);

     

    展开全文
  • 好用的对象xmlxml对象工具-支持集合嵌套转换Java实现) 网上找了很多转换工具,对于自己的业务都不是很合适,所以总结了一下网上的方案,最终定下来是这样子的,主要使用dom4j做操作 maven依赖 <...

    好用的对象转xml、xml转对象工具类-支持集合嵌套转换(Java实现)

    网上找了很多转换工具,对于自己的业务都不是很合适,所以总结了一下网上的方案,最终定下来是这样子的,主要使用dom4j做操作

    maven依赖

    <dependency>
       <groupId>dom4j</groupId>
       <artifactId>dom4j</artifactId>
       <version>1.6.1</version>
    </dependency>
    package com.aier.cloud.biz.crm.utils;
    
    
    import org.apache.commons.lang3.StringUtils;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.SAXReader;
    import org.dom4j.io.XMLWriter;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    import javax.xml.XMLConstants;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.transform.OutputKeys;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    import java.io.*;
    import java.lang.reflect.Field;
    import java.math.BigDecimal;
    import java.net.URL;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    /**
     * @author szz
     * @since 2019/8/5 10:36
     */
    public class XmlUtil {
    
        /**
         * XML格式字符串转换为Map
         *
         * @param strXML XML字符串
         * @return XML数据转换后的Map
         * @throws Exception
         */
        public static Map<String, String> xmlToMap(String strXML) throws Exception {
            try {
                Map<String, String> data = new HashMap<String, String>();
                DocumentBuilder documentBuilder = newDocumentBuilder();
                InputStream stream = new ByteArrayInputStream(strXML.getBytes("GB2312"));
                org.w3c.dom.Document doc = documentBuilder.parse(stream);
                doc.getDocumentElement().normalize();
                NodeList nodeList = doc.getDocumentElement().getChildNodes();
                for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                    Node node = nodeList.item(idx);
                    if (node.getNodeType() == Node.ELEMENT_NODE) {
                        org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                        data.put(element.getNodeName(), element.getTextContent());
                    }
                }
                try {
                    stream.close();
                } catch (Exception ex) {
                    // do nothing
                }
                return data;
            } catch (Exception ex) {
                throw ex;
            }
    
        }
    
    
        public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
            documentBuilderFactory.setXIncludeAware(false);
            documentBuilderFactory.setExpandEntityReferences(false);
    
            return documentBuilderFactory.newDocumentBuilder();
        }
    
        public static org.w3c.dom.Document newDocument() throws ParserConfigurationException {
            return newDocumentBuilder().newDocument();
        }
        /**
         * 将Map转换为XML格式的字符串
         *
         * @param data Map类型数据
         * @return XML格式的字符串
         * @throws Exception
         */
        public static String mapToXml(Map<String, String> data, String baseTagName, String encoding) throws Exception {
            org.w3c.dom.Document document = newDocument();
            org.w3c.dom.Element root = document.createElement(baseTagName);
            document.appendChild(root);
            for (String key : data.keySet()) {
                String value = data.get(key);
                if (value == null) {
                    value = "";
                }
                value = value.trim();
                org.w3c.dom.Element filed = document.createElement(key);
                filed.appendChild(document.createTextNode(value));
                root.appendChild(filed);
            }
            TransformerFactory tf = TransformerFactory.newInstance();
            Transformer transformer = tf.newTransformer();
            DOMSource source = new DOMSource(document);
            transformer.setOutputProperty(OutputKeys.ENCODING, encoding);
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            StringWriter writer = new StringWriter();
            StreamResult result = new StreamResult(writer);
            transformer.transform(source, result);
            String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
            try {
                writer.close();
            } catch (Exception ex) {
            }
            return output;
        }
    
    
        /**
         * 重载,默认根节点为Request 编码格式为GB2312
         *
         * @param data
         * @return
         * @throws Exception
         */
        public static String mapToXml(Map<String, String> data) throws Exception {
            return mapToXml(data, "Request", "GB2312");
        }
    
    
        /**
         * 反射设置实体不同类型字段的值 <暂时只支持 日期 字符串 boolean Integer值设置 待扩建>
         *
         * @param field
         * @param obj
         * @param value
         * @throws Exception
         */
        public static void convertValue(Field field, Object obj, String value)
                throws Exception {
            SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            if (field.getGenericType().toString().equals("class java.lang.Integer")) {
                field.set(obj, Integer.parseInt(value));
            } else if (field.getGenericType().toString().equals("boolean")) {
                field.set(obj, Boolean.parseBoolean(value));
            } else if (field.getGenericType().toString().equals(
                    "class java.util.Date")) {
                field.set(obj, sim.parse(value));
            } else {
                field.set(obj, value);
            }
    
        }
    
        /**
         * 解析xml文件返回保存Map的集合,map中可能包含key值为returnCode、desc、totalCount等单字段.
         * 也可能包含存储对象为List<cls>的集合值.
         * 获取List值key cls_List
         *
         * @param requestPath
         * @param cls
         * @return map
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> parseXml2Map(String requestPath,
                                                       Class<?> cls) throws Exception {
            Map<String, Object> maps = new HashMap<String, Object>();
            List<Object> lists = new ArrayList<Object>();
            SAXReader saxReader = new SAXReader();
            //当传入的是xml字符串时,采用这个方案
            Document doc = doc = DocumentHelper.parseText(requestPath);
            Element et = doc.getRootElement();
            // 标记List是否为空
            // boolean bool = true ;
            // 根节点名字
            List<Element> rList = et.elements();
            for (Element element : rList) {
                List<Element> rLists = element.elements();
                if (!rLists.isEmpty() && rLists.size() > 0) {
                    //bool = false;
                    // 判断二级节点
                    for (Element e : rLists) {
                        List<Element> li = e.elements();
                        Class<?> cl = (Class<?>) Class.forName(cls.getName());
                        Object ob = cl.newInstance();
                        for (Element element2 : li) {
                            String name = element2.getName();
                            String value = element2.getText();
                            Field field = ob.getClass().getDeclaredField(name);
                            field.setAccessible(true);
                            convertValue(field, ob, value);
                        }
                        lists.add(ob);
                    }
                } else {
                    maps.put(element.getName(), element.getText());
                }
                //maps.put(cls.getSimpleName() + "_List", lists);
                maps.put("ItemList", lists);
            }
            return maps;
        }
    
    
        /**
         * https://www.cnblogs.com/interdrp/p/5825453.html1
         * 解析xml文件返回保存cls的List集合,如果返回码ResultCode=1时则返回List为null
         *
         * @param xml
         * @param cls
         * @return
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static List<?> parseXml2List(String xml, Class<?> cls)
                throws Exception {
            List<Object> lists = null;
            Document doc = DocumentHelper.parseText(xml);
            Element et = doc.getRootElement();
            String root = et.getName();
            // 查看返回码是否为真.
            List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
            if (!list.isEmpty() && list.size() > 0) {
                Element element = list.get(0);
                String returnResult = element.getText();
                if (returnResult.equals("0")) {
                    List<Element> father = doc.selectNodes("//" + root + "/" + cls.getSimpleName() + "s");
                    //判断对象父节点是否有包含数据
                    if (father != null && !father.isEmpty() && father.size() == 1) {
                        List<Element> userLists = father.get(0).elements();
                        if (userLists != null && !list.isEmpty()) {
                            lists = new ArrayList<Object>();
                            for (Element e : userLists) {
                                List<Element> li = e.elements();
                                Class<?> cl = (Class<?>) Class.forName(cls.getName());
                                Object ob = cl.newInstance();
                                for (Element element2 : li) {
                                    String name = element2.getName();
                                    String value = element2.getText();
                                    Field field = ob.getClass().getDeclaredField(name);
                                    field.setAccessible(true);
                                    convertValue(field, ob, value);
                                }
                                lists.add(ob);
                            }
                        }
                    }
                }
    
            }
            return lists;
        }
    
        /**
         * 解析xml文件返回保存cls的List集合,如果返回码ResultCode=1时则返回List为null
         *
         * @param url
         * @param cls
         * @return
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static List<?> parseXml2List(URL url, Class<?> cls)
                throws Exception {
            List<Object> lists = null;
            SAXReader saxReader = new SAXReader();
            Document doc = saxReader.read(url);
            Element et = doc.getRootElement();
            String root = et.getName();
            // 查看返回码是否为真.
            List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
            if (!list.isEmpty() && list.size() > 0) {
                Element element = list.get(0);
                String returnResult = element.getText();
                if (returnResult.equals("0")) {
                    List<Element> father = doc.selectNodes("//" + root + "/" + cls.getSimpleName() + "s");
                    //判断对象父节点是否有包含数据
                    if (father != null && !father.isEmpty() && father.size() == 1) {
                        List<Element> userLists = father.get(0).elements();
                        if (userLists != null && !list.isEmpty()) {
                            lists = new ArrayList<Object>();
                            for (Element e : userLists) {
                                List<Element> li = e.elements();
                                Class<?> cl = (Class<?>) Class.forName(cls.getName());
                                Object ob = cl.newInstance();
                                for (Element element2 : li) {
                                    String name = element2.getName();
                                    String value = element2.getText();
                                    Field field = ob.getClass().getDeclaredField(name);
                                    field.setAccessible(true);
                                    convertValue(field, ob, value);
                                }
                                lists.add(ob);
                            }
                        }
                    }
                }
    
            }
            return lists;
        }
    
        /**
         * 解析xml文件返回保存Map的集合,map中可能包含key值为returnCode、desc、totalCount等单字段.
         * 也可能包含存储对象为List<cls>的集合值.
         * 获取List值key cls_List
         *
         * @param requestPath
         * @param cls
         * @return map
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> parseXml2MapOld(String requestPath,
                                                          Class<?> cls) throws Exception {
            Map<String, Object> maps = new HashMap<String, Object>();
            List<Object> lists = new ArrayList<Object>();
            SAXReader saxReader = new SAXReader();
            //Document doc = saxReader.read(new File(requestPath));
            //Document doc = saxReader.read(new URL(requestPath));
            //当传入的是xml字符串时,采用这个方案
            Document doc = doc = DocumentHelper.parseText(requestPath);
            Element et = doc.getRootElement();
            // 标记List是否为空
            // boolean bool = true ;
            // 根节点名字
            List<Element> rList = et.elements();
            for (Element element : rList) {
                List<Element> rLists = element.elements();
                if (!rLists.isEmpty() && rLists.size() > 0) {
                    //bool = false;
                    // 判断二级节点
                    for (Element e : rLists) {
                        List<Element> li = e.elements();
                        Class<?> cl = (Class<?>) Class.forName(cls.getName());
                        Object ob = cl.newInstance();
                        for (Element element2 : li) {
                            String name = element2.getName();
                            String value = element2.getText();
                            Field field = ob.getClass().getDeclaredField(name);
                            field.setAccessible(true);
                            convertValue(field, ob, value);
                        }
                        lists.add(ob);
                    }
                } else {
                    maps.put(element.getName(), element.getText());
                }
                //maps.put(cls.getSimpleName() + "_List", lists);
                maps.put("ItemList", lists);
            }
            return maps;
        }
    
        /**
         * 只获取返回码0为保存成功(true)1为保存失败(false)
         */
        @SuppressWarnings("unchecked")
        public static boolean parseXmlReturnCode(String xml) {
            boolean bool = false;
            try {
                Document doc = DocumentHelper.parseText(xml);
                Element et = doc.getRootElement();
                String root = et.getName();
                // 查看返回码是否为真.
                List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
                if (!list.isEmpty() && list.size() > 0) {
                    Element element = list.get(0);
                    String returnResult = element.getText();
                    if (returnResult.equals("0")) {
                        bool = true;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bool;
        }
    
    
        /**
         *
         * https://blog.csdn.net/javaniche/article/details/79655473
         * 格式化输出xml
         *
         * @param document
         * @return
         * @throws DocumentException
         * @throws IOException
         */
        public static String formatXml(Document document) throws DocumentException, IOException {
            // 格式化输出格式
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GB2312");
            StringWriter writer = new StringWriter();
            // 格式化输出流
            XMLWriter xmlWriter = new XMLWriter(writer, format);
            // 将document写入到输出流
            xmlWriter.write(document);
            xmlWriter.close();
            return writer.toString();
        }
    
        public static Document map2Xml(Map<String, Object> map, String node, String type) throws Exception {
            Document document = DocumentHelper.createDocument();
            Element nodeElement = document.addElement(node);
            map2Xml(map, nodeElement, type);
            return document;
        }
    
        public static final String map2Xml_TYPE_listElementWrapper = "1";
    
        private static void map2Xml(Map<String, Object> map, Element nodeElement, String type) throws Exception {
    
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String key = (String) entry.getKey();
                Object value = entry.getValue();
                if ((value instanceof List) && StringUtils.isBlank(type)) {
                    Element element = nodeElement.addElement(key);
                    List<Map<String, Object>> list = (List<Map<String, Object>>) value;
                    for (Map<String, Object> subMap : list) {
                        Element itemElement = element.addElement("Item");
                        map2Xml(subMap, itemElement, type);
                    }
                } else if ((value instanceof List) && StringUtils.isNotBlank(type) && type.contains(map2Xml_TYPE_listElementWrapper)) {
                    List<Map<String, Object>> list = (List<Map<String, Object>>) value;
                    for (Map<String, Object> subMap : list) {
                        Element element = nodeElement.addElement(key);
                        map2Xml(subMap, element, type);
                    }
                } else if (value instanceof Map) {
                    Element element = nodeElement.addElement(key);
                    Map<String, Object> valueMap = (Map<String, Object>) value;
                    map2Xml(valueMap, element, type);
                } else if (value instanceof String) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText((String) value);
                } else if (value instanceof Integer) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText(((Integer) value).toString());
                } else if (value instanceof BigDecimal) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText(((BigDecimal) value).toString());
                } else if (value instanceof Date) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(value)).toString());
                } else {
                    throw new Exception("不支持的 value 类型");
                }
            }
        }
    
    
    }
    

     

    展开全文
  • java对象转换xml格式字符串

    千次阅读 2017-06-13 22:35:49
    它提供了管理实现 JAXB 绑定框架操作所需的 XML/Java 绑定信息的抽象,这些操作包括:解组、编组和验证。 1.编写工具 /** * Jaxb工具 * * @author LittleNewbie * @date 2016年10月11日 */ public ...

    它提供了管理实现 JAXB 绑定框架操作所需的 XML/Java 绑定信息的抽象,这些操作包括:解组、编组和验证。

    1.编写工具类

    /**
     * Jaxb工具类
     *
     * @author LittleNewbie
     * @date 2016年10月11日
     */
    public class JaxbUtil {
    
        public static final String DEFAULT_ENCODING = "UTF-8";
    
        /**
         * pojo转换成xml 默认编码UTF-8
         *
         * @param obj 待转化的对象
         * @return xml格式字符串
         * @throws Exception JAXBException
         */
        public static String convertToXml(Object obj) throws Exception {
            return convertToXml(obj, DEFAULT_ENCODING);
        }
    
        /**
         * pojo转换成xml
         *
         * @param obj 待转化的对象
         * @param encoding 编码
         * @return xml格式字符串
         * @throws Exception JAXBException
         */
        public static String convertToXml(Object obj, String encoding) throws Exception {
            String result = null;
    
            JAXBContext context = JAXBContext.newInstance(obj.getClass());
            Marshaller marshaller = context.createMarshaller();
            // 指定是否使用换行和缩排对已编组 XML 数据进行格式化的属性名称。
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
    
            StringWriter writer = new StringWriter();
            marshaller.marshal(obj, writer);
            result = writer.toString();
    
            return result;
        }
    
        /**
         * xml转换成JavaBean
         *
         * @param xml xml格式字符串
         * @param t 待转化的对象
         * @return 转化后的对象
         * @throws Exception JAXBException
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertToJavaBean(String xml, Class<T> t) throws Exception {
            T obj = null;
            JAXBContext context = JAXBContext.newInstance(t);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            obj = (T) unmarshaller.unmarshal(new StringReader(xml));
            return obj;
        }
    }

    2.为pojo简单java对象添加注解

    2.1 xml顶级元素

    /**
     * 请求报文基础类
     * 请求报文的实现方式:
     * 1.使用默认的顶级标签元素<Request><Request/>:直接创建该类对象;
     * 2.使用其他顶级标签元素:继承该类,并添加注解@XmlRootElement(name = "rootName") rootName区分大小写
     *
     * @author LittleNewbie
     * @date 2016年10月11日
     */
    //类中的每个非静态、非瞬态字段将会自动绑定到 XML,除非由 XmlTransient 注释
    @XmlAccessorType(XmlAccessType.FIELD)
    //xml顶级元素标签
    @XmlRootElement(name = "Request")
    public class RequestPacket {
    
        /**
         * 请求包体消息    
        */
        private MsgBody msgBody;
    
        public RequestPacket() {
        }
    
        //getter setter...
    }

    2.2 xml顶级元素,继承2.1

    /**
     * 数据请求报文-根节点 
     * @author LittleNewbie
     * @date 2016年10月11日
     *
     */
    @XmlRootElement(name = "DATARequest")
    public class DataRequestPacket extends RequestPacket {
    
        public DataRequestPacket() {
        }
    }

    2.3 xml元素标签,包含其他元素标签 

    /**
     * 请求包体消息
     * @author LittleNewbie
     * @date 2016年10月11日
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    public class MsgBody {
    
    	@XmlElementWrapper(name = "CONDITIONLIST")
    	@XmlElement(name = "CONDITION")
    	private List<String> conditionList;
    
    	/**
    	 * 如果不添加XmlElement注解,默认以属性名生成xml元素标签
    	 */
    	@XmlElement(name = "DATALIST")
    	private String dataList;
    
    	
    	private String config;
    	
    
    	public MsgBody() {
    	}
    
    	//getter setter...
    }

     

    3.测试代码及运行结果

    测试代码

                    RequestPacket root = new DataRequestPacket();
    
    		MsgBody body = new MsgBody();
    
    		String[] conditions = { "condition_1", "condition_2" };
    		body.setConditionList(Arrays.asList(conditions));
    		body.setDataList("");
                    //这里不设置config值,属性值为null,将不会转为xml标签
                    //body.setConfig("");
    
    		root.setMsgBody(body);
    		String xmlStr = JaxbUtil.convertToXml(root);
    		System.out.println(xmlStr);

     

    结果

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <!-- 顶级元素为DataRequestPacket的@XmlRootElement注解值 -->
    <DATARequest>
        <!-- 默认为属性(字段)名 -->
        <msgBody>
            <!-- 这里对照pojo一看就懂了 -->
            <CONDITIONLIST>
                <CONDITION>condition_1</CONDITION>
                <CONDITION>condition_2</CONDITION>
            </CONDITIONLIST>
            <!-- @XmlElement注解 -->
            <DATALIST></DATALIST>
            <!-- config值为null,不对其进行转换 -->
        </msgBody>
    </DATARequest>

    4.附加操作

    4.1 过滤 standalone="yes"

    xmlStr.replaceFirst(" standalone=\"yes\"", "")

    4.2 将xml元素标签转为大写

    String regex = "<(/*[A-Za-z]+)>";
    Matcher matcher = Pattern.compile(regex).matcher(xmlStr);
    StringBuffer sb = new StringBuffer();
    while (matcher.find()) {
    	matcher.appendReplacement(sb, "<" + matcher.group(1).toUpperCase() + ">");
    
    }
    matcher.appendTail(sb);
    sb.toString();

    4.3 获取xml元素标签内容

    4.3.1 xml元素标签唯一

    /**
         * 获取xml字符串中元素标签值
         * <p>xml中元素标签唯一</p>
         *
         * @param responseXml 响应报文(xml字符串格式)
         * @param element     元素名(不区分大小写)
         * @return
         * @throws Exception
         */
        public static String getXmlSingleElementValue(String responseXml, String element) {
            //元素名大写<ELEMENT>(.*)<ELEMENT/>
            StringBuffer regex = new StringBuffer();
            regex.append("<").append(element.toUpperCase()).append(">");
            regex.append("(.*)");
            regex.append("</").append(element.toUpperCase()).append(">");
    
            String str = "";
            Matcher matcher = Pattern.compile(regex.toString()).matcher(responseXml);
            while (matcher.find()) {
                str = matcher.group(1);
            }
            return str;
        }

    4.3.1 xml元素标签不唯一(存在多个)

       /**
         * 获取xml字符串中元素标签值
         * <p>xml存在多个该元素标签</p>
         * <p>exmple:<DATA></DATA></p>
         *
         * @param responseXml 响应报文(xml字符串格式)
         * @param element     元素名(不区分大小写)
         * @return
         * @throws Exception
         */
        public static List<String> getXmlListElementValue(String responseXml, String element) {
            List<String> list = new ArrayList<String>();
            //元素名大写<ELEMENT>([^</ELEMENT>]*)</ELEMENT>
            StringBuffer regex = new StringBuffer();
            regex.append("<").append(element.toUpperCase()).append(">");
            regex.append("([^</" + element.toUpperCase() + ">]*)");
            regex.append("</").append(element.toUpperCase()).append(">");
            Matcher matcher = Pattern.compile(regex.toString()).matcher(responseXml);
            while (matcher.find()) {
                list.add(matcher.group(1));
            }
            return list;
        }

     

    展开全文
  • java xml与实体对象 互相转换

    千次阅读 2019-01-10 16:07:03
    最近在项目中一直出现Java对象XML之间的相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长的要求进行写代码的同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体的使用缘由。...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • Java把一个对象转换xml数据

    千次阅读 2019-08-23 15:13:43
    在一个实体上添加注解 @XmlRootElement(name="AppAccountList") public class AppAccountListVO { private List<AppAccountEntity> appAccountList; public AppAccountListVO() {} public App...
  • Java对象XML相互转换

    万次阅读 多人点赞 2018-08-19 13:33:40
    最近在项目中一直出现Java对象XML之间的相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长的要求进行写代码的同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体的使用缘由。...
  • 使用方法2.1 xml报文示例2.2 对象xml标签的添加2.3 xml对象的示例2.4 对象xml的示例 1. xml工具代码   先贴上工具代码。如下: package znxd.lxynzl.bank.base; import javax.xml.bind.JAXBContext; ...
  • Java 对象xml转换工具

    千次阅读 2016-06-13 14:49:22
    这里默认get和set方法来组织xml,没有方法的属性使用注解来组织xml。当然还可以不默认get和set方法,用@XmlAccessorType(XmlAccessType.FIELD)  package com.mcp.bean.yeepay; import com.mcp.cons.YeePa
  • 如何将XML转换Java对象

    千次阅读 2019-07-27 00:43:44
    1.首先创建citylist.xml文件,放在resource目录下,文件内容如下: <?xml version="1.0" encoding="UTF-8"?> <c c1="0"> <d d1="101280101" d2="广州" d3="guangzhou" d4="广东"/> <d d1=...
  • Java对象XML的相互转换

    千次阅读 2017-10-17 11:10:52
     可以根据XML Schema产生Java类的技术.JAXB也提供了将XML实例文档反向生成Java对象树的方法,并能将Java对象树的内容重新写到XML实例文档. JAXB 2.0是JDK 1.6的组成部分。JAXB 2.2.3是JDK 1.7的组成部分。在实际...
  • 简单Java类XML之间的转换

    千次阅读 2018-09-17 14:25:00
    需要的jar包:xmlpull_1_0_5.jar,... 1、工具XstreamUtil    package com.learn.util;  import com.thoughtworks.xstream.XStream;  import com.thoughtworks.xstream.io.xml.DomDriver;  /** *...
  • 微信支付之 Java对象xml之间的转换

    千次阅读 2018-08-28 09:57:21
    最新微信支付中统一下单时,参数需要以xml格式去发送,下面使用XStream进行转换 首先需要两个jar包 &lt;dependency&gt; &lt;groupId&gt;xpp3&lt;/groupId&gt; &lt;artifactId&...
  • NULL 博文链接:https://yangyongbyjava.iteye.com/blog/2068636
  • 关于JAXB的介绍,见:... 测试: package com.solin.test; import java.util.ArrayList; import java.util.List; public class Test { public static void main
  • 主要是用来实体xml的相互转换, 如果需要将xml存进数据库,oracle建议使用 clob类型 这样直接可以当成字符串来使用首先需要引用包 需要的jar包如下: xpp3_min-1.1.4c.jar xstream-1.3.jar或者使用maven ...
  • 一、前言之前在做一个微信公众号的项目,项目中有用到一种技术,将调用接口后返回的xml字符串转换对象java bean),个人觉得这种方式还是蛮好用的,所以在这里分享下。二、案列分享1.非注解方式实现对象java ...
  • JAXB可以轻松实现java对象xml的互相转换 首先准备好一个JavaBean供实验: 注意 1、文件注解:@XmlRootElement不可缺少 2、2个Student的构造方法不能少   XmlToJava //xml转换Java @Test public void test02...
  • 玩转Java对象XML相互转换

    万次阅读 多人点赞 2013-12-13 18:39:08
    最近在项目中一直出现Java对象XML之间的相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长的要求进行写代码的同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体的使用缘由。...
  • java读取xml文件并转换对象,并进行修改
  • JAVA XML对象 对象XML

    千次阅读 2018-10-18 11:17:37
    在网上看了许多XML跟Obj互相转换的Demo,但是都很复杂,现在推荐一个极度简单好理解的XML和Obj互转的例子: JacksonXML,只需要简单的几个注解就能完成XML和Obj的相互转换 假设有如下xml报文: <?xml version...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • 如何将XML转换java对象 /** * XML转成对象 * * @param * @param inputXML 需要转对象XML * @param classes 包含的类类对象里的自定义,数组传入 * @return 返回对象 */ public static T toEntity(String ...
  • 今天我们要探讨的一个问题是,如何将xml格式的字符串转换对象,以及对象转换xml字符串。 简介 现如今,虽然数据的传输大部分都是用json格式来进行传输,但是xml毕竟也会有一些老的项目在进行使用,身为一个万能...
  • XML文件数据转换JAVA实体

    千次阅读 2018-07-09 13:47:59
    以城市列表为例.citylist.xml&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;c c1="0"&gt; &lt;d d1="101280101" d2="广州" d3="...
  • java实体xml之间的转换

    千次阅读 2018-06-25 16:45:24
    一、XStream的用途 ... XStream是一个Java对象XML相互转换的工具,很好很强大。提供了所有的基础类型、数组、集合等类型直接转换的支持。&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,771
精华内容 74,708
关键字:

java类转换xmlstring对象

java 订阅