众所周知，大家在微信开发工程中，由于微信开发文档中，对于消息的接收发送都是基础xml数据的（太坑了），所以我们需要对XML进行解析转换；

1.我们先引入所需要的依赖 dom4j （解析xml的），xstream（可以将对象，以及复杂对象转换为xml）;

<dependency>

<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>

<dependency>
<groupId>jdom</groupId>
<artifactId>jdom</artifactId>
<version>1.1</version>
</dependency>

<!-- 转换xml类 -->
<dependency>
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.4.5</version>
</dependency>

先给大家介绍一下Java 内置的 jaxp xml 解析器获取的方法，以及Document对象（可以忽视不看）

  1. /**
  2.      *  获取 jaxp XML 解析器
  3.      *  位于javax 包中，Java 内置支持
  4.      * @throws ParserConfigurationException
  5.      */
  6.  
  7.     public static  DocumentBuilder getJaxpXmlBuilder() throws ParserConfigurationException {
  8.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  9.         DocumentBuilder builder = factory.newDocumentBuilder();
  10.         return builder;
  11.     }
  12.  
  13. /**
  14.      * jaxp 获取Document 对象,通过一个文件/流对象
  15.      * @throws ParserConfigurationException
  16.      * @throws IOException
  17.      * @throws SAXException
  18.      */
  19.     public static Document getJaxpDocument(DocumentBuilder builder,Object file) throws Exception {
  20.         DocumentBuilder xmlBuilder;
  21.         if((xmlBuilder=builder)==null) {
  22.             xmlBuilder=getJaxpXmlBuilder();
  23.         }
  24.         if(file instanceof File) {
  25.             return xmlBuilder.parse((File)file);
  26.         }else if(file instanceof InputStream) {
  27.             return xmlBuilder.parse((InputStream)file);
  28.         }else {
  29.             return null;
  30.         }
  31.     }

获取dom4j  xml 解析器获取的方法，以及Document对象

  1.     /**
  2.      * dom4j
  3.      * 初始化，获取document 对象通过输入url的方式
  4.      * @param readObject 可以是流，也可以是文件，也可以是URL ，也可以是InputSource
  5.      * @return
  6.      * @throws DocumentException
  7.      */
  8.     public static org.dom4j.Document getDom4jDocument(Object readObject) throws DocumentException {
  9.         SAXReader reader =new SAXReader();
  10.         org.dom4j.Document document ;
  11.         if(readObject instanceof InputStream) {
  12.             document =reader.read((InputStream)readObject);
  13.         }else if(readObject instanceof File) {
  14.             document =reader.read((File)readObject);
  15.         }else if(readObject instanceof URL) {
  16.             document =reader.read((URL)readObject);
  17.         }else if(readObject instanceof InputSource){
  18.             document =reader.read((InputSource)readObject);
  19.         }else {
  20.             //没有匹配的的XML
  21.             document =null;
  22.         }
  23.  
  24.         return document;
  25.     }

-------------------------------------------重点方法-------------------

2.开始编码 --我会对下面utils类进行解释

先介绍使用XStream 将XML 转换为一个对象，将一个对象转换为XML的方法，并附上实际demo；（需要引入 XStream 包）

（1）XStream 将XML 转换为对象

  1. /**
  2.      * 将xml 字符串转换为 pojo 对象
  3.      * 确保已经引入xstream 的jar 包
  4.      * 以及类上面使用了@XStreamAlias("你定义的")；
  5.      * @param poClass，转化po的Class
  6.      * @param xml
  7.      * @return
  8.      */
  9.     @SuppressWarnings("unchecked")
  10.     public static <T> T xmlToPojo(Class<T> poClass,String xml) {
  11.  
  12.         XStream xstream =new XStream();
  13.         xstream.processAnnotations(poClass);
  14.         xstream.processAnnotations(getInnerClasses(poClass));
  15.         return (T)xstream.fromXML(xml);
  16.  
  17.     }

（2）. XStream 将一个XML 流转换为对象；

  1. /**
  2.      * 将inputstream转换为 pojo 对象
  3.      * 确保已经引入xstream 的jar 包
  4.      * 以及类上面使用了@XStreamAlias("你定义的")；
  5.      * @param poClass
  6.      * @param xml
  7.      * @return
  8.      */
  9.     @SuppressWarnings("unchecked")
  10.     public static <T> T streamToPojo(Class<T> poClass,InputStream stream) {
  11.  
  12.         XStream xstream =new XStream();
  13.         xstream.processAnnotations(poClass);
  14.         xstream.processAnnotations(getInnerClasses(poClass));
  15.         return (T)xstream.fromXML(stream);
  16.  
  17.     }

（3）.XStream 将对象转换为xml

  1. /**
  2.      * 使用 xstream 将一个人pojo 对象转换为xml 字符串
  3.      * 确保已经引入xstream 的jar 包
  4.      * 以及类上面使用了@XStreamAlias("你定义的")；
  5.      * @param pojo
  6.      * @return
  7.      */
  8.     public static <T> String pojoToXml(T pojo) {
  9.  
  10.         Class<?> poClass = pojo.getClass();
  11.         XStream xstream =new XStream();
  12.         xstream.processAnnotations(poClass);
  13.         xstream.processAnnotations(getInnerClasses(poClass));
  14.         return xstream.toXML(pojo);
  15.  
  16.     }
  1. getInnerClasses（）方法：
  1. /**
  2.      * 得到一个类的内部类
  3.      * @param clz
  4.      * @return
  5.      */
  6.     public static Class<?>[] getInnerClasses(Class<?> clz) {
  7.         Class<?>[] innerClasses = clz.getClasses();
  8.         if (innerClasses == null) {
  9.           return null;
  10.         }
  11.  
  12.         List<Class<?>> result = new ArrayList<>();
  13.         result.addAll(Arrays.asList(innerClasses));
  14.         for (Class<?> inner : innerClasses) {
  15.           Class<?>[] innerClz = getInnerClasses(inner);
  16.           if (innerClz == null) {
  17.             continue;
  18.           }
  19.  
  20.           result.addAll(Arrays.asList(innerClz));
  21.         }
  22.  
  23.         return result.toArray(new Class<?>[0]);
  24.       }

关于以上方法的demo 如下，让大家加深理解：

  1. package com.baseknow.testclass;
  2.  
  3. import java.util.List;
  4.  
  5. import com.thoughtworks.xstream.annotations.XStreamAlias;
  6. //pojo
  7. @XStreamAlias("xml")
  8. public class XmlPojo {
  9.     @XStreamAlias("timespace")
  10.     private String times;
  11.     @XStreamAlias("unionid")
  12.     private String unionid;
  13.     @XStreamAlias("openid")
  14.     private String openid;
  15.     @XStreamAlias("items")
  16.     private List<Msg> msg;
  17.  
  18.     public XmlPojo(String times,String unionid,String openid){
  19.         this.times =times;
  20.         this.unionid =unionid;
  21.         this.openid =openid;
  22.     }
  23.  
  24.     @XStreamAlias("item")
  25.     public static class  Msg{
  26.         @XStreamAlias("content")
  27.         private String content;
  28.         @XStreamAlias("tocode")
  29.         private String code;
  30.         public Msg(String content,String code){
  31.             this.content=content;
  32.             this.code=code;
  33.         }
  34.     }
  35.  
  36.     public List<Msg> getMsg() {
  37.         return msg;
  38.     }
  39.     public void setMsg(List<Msg> msg) {
  40.         this.msg = msg;
  41.     }
  42.     public String getTimes() {
  43.         return times;
  44.     }
  45.     public void setTimes(String times) {
  46.         this.times = times;
  47.     }
  48.     public String getUnionid() {
  49.         return unionid;
  50.     }
  51.     public void setUnionid(String unionid) {
  52.         this.unionid = unionid;
  53.     }
  54.     public String getOpenid() {
  55.         return openid;
  56.     }
  57.     public void setOpenid(String openid) {
  58.         this.openid = openid;
  59.     }
  60.  
  61. }

main方法：--大家可以进行测试

  1.     public static void main(String[] args) {
  2.  
  3.         XmlPojo po =new XmlPojo("123","123","123");
  4.  
  5.         Msg msg =new Msg("ss","ss");
  6.         Msg msg2 =new Msg("ss1","ss1");
  7.         List li =new ArrayList<>();
  8.         li.add(msg2);li.add(msg);
  9.         po.setMsg(li);
  10.         String pojoToXml = XmlParseUtils.pojoToXml(po);
  11.         System.out.println(pojoToXml);
  12.         //转pojo
  13.         XmlPojo poo = XmlParseUtils.xmlToPojo(po.getClass(), pojoToXml);
  14.         System.out.println(poo);
  15.     }

OK，XStream 的常用方法就到这里，对于我来说，用XStream 就够了，很强大，很好扩展，更多需要学习它的api，下面介绍几个也会用到的方法

使用common.io 包下的 IOUtils 可以很方便的将input stream 转换为xml 字符串

  1. 　public static String xmlStreamToString (HttpServletRequest request) throws Exception{
  2. 　　String result =IOUtils.toString(request.getInputStream(), "utf-8");
  3. 　　return result;
  4. }

dom4j 将xml数据流转换为map

  1.     public static Map<String,String> xmlTOMap(HttpServletRequest request) throws Exception{
  2.  
  3.         Map<String,String> map =new HashMap<String,String>();
  4.         SAXReader reader =new SAXReader();
  5.         InputStream ins=null;
  6.         try {
  7.              ins =request.getInputStream();
  8.         } catch (IOException e) {
  9.  
  10.             e.printStackTrace();
  11.         }
  12.         Document docment =reader.read(ins);//读取流对象
  13.         Element root=docment.getRootElement();
  14.         List<Element> list =root.elements();
  15.         for(Element ele:list) {
  16.  
  17.             map.put(ele.getName(), ele.getText());
  18.         }
  19.  
  20.         return map;
  21.  
  22.     }

 使用dom4j将XML转换为Map

  1. public static Map<String,String> StrXmlTOMap(String strXml) throws Exception{
  2.  
  3.         Map<String,String> map =new HashMap<String,String>();
  4.         Document docment = DocumentHelper.parseText(strXml);
  5.         Element root=docment.getRootElement();
  6.         List<Element> list =root.elements();
  7.         for(Element ele:list) {
  8.  
  9.             map.put(ele.getName(), ele.getText());
  10.         }
  11.  
  12.         return map;
  13.  
  14.     }
  15.

（4）将Map转换为Xml

  1. /*
  2.      * Map转换成Xml
  3.      */
  4.     public static String MapToXml(Map<String,Object> parameters){
  5.         StringBuffer sb = new StringBuffer();
  6.         sb.append("<xml>");
  7.         Set es = parameters.entrySet();
  8.         Iterator it = es.iterator();
  9.         while(it.hasNext()) {
  10.             Map.Entry entry = (Map.Entry)it.next();
  11.             String k = (String)entry.getKey();
  12.             String v = (String)entry.getValue();
  13.             if ("attach".equalsIgnoreCase(k)||"body".equalsIgnoreCase(k)||"sign".equalsIgnoreCase(k)) {
  14.                 sb.append("<"+k+">"+"<![CDATA["+v+"]]></"+k+">");
  15.             }else {
  16.                 sb.append("<"+k+">"+v+"</"+k+">");
  17.             }
  18.         }
  19.         sb.append("</xml>");
  20.         return sb.toString();
  21.     }

完整版附上：

  1. package com.baseknow.utils;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.net.URL;
  7. import java.util.ArrayList;
  8. import java.util.Arrays;
  9. import java.util.List;
  10. import java.util.Properties;
  11. import javax.xml.parsers.DocumentBuilder;
  12. import javax.xml.parsers.DocumentBuilderFactory;
  13. import javax.xml.parsers.ParserConfigurationException;
  14. import javax.xml.xpath.XPath;
  15. import javax.xml.xpath.XPathFactory;
  16.  
  17. import org.apache.commons.io.IOUtils;
  18. import org.dom4j.DocumentException;
  19. import org.dom4j.Element;
  20. import org.dom4j.io.SAXReader;
  21. import org.w3c.dom.Document;
  22. import org.w3c.dom.NamedNodeMap;
  23. import org.w3c.dom.Node;
  24. import org.xml.sax.InputSource;
  25. import org.xml.sax.SAXException;
  26.  
  27. import com.thoughtworks.xstream.XStream;
  28. import com.thoughtworks.xstream.annotations.XStreamAlias;
  29.  
  30. /**
  31.  * xml 工具类
  32.  * 包含jaxp 解析器的创建；
  33.  * Xpath 解析器的创建；
  34.  * dom4j 解析器
  35.  * dom4j 解析器创建；
  36.  * 获取XML document 对象；
  37.  * 获取Node attriute
  38.  * xml 的转换
  39.  * @author iscys
  40.  *
  41.  */
  42. public class XmlParseUtils {
  43.  
  44.     /**
  45.      * 使用 xstream 将一个人pojo 对象转换为xml 字符串
  46.      * 确保已经引入xstream 的jar 包
  47.      * 以及类上面使用了@XStreamAlias("你定义的")；
  48.      * @param pojo
  49.      * @return
  50.      */
  51.     public static <T> String pojoToXml(T pojo) {
  52.  
  53.         Class<?> poClass = pojo.getClass();
  54.         XStream xstream =new XStream();
  55.         xstream.processAnnotations(poClass);
  56.         xstream.processAnnotations(getInnerClasses(poClass));
  57.         return xstream.toXML(pojo);
  58.  
  59.     }
  60.  
  61.     /**
  62.      * 将xml 字符串转换为 pojo 对象
  63.      * 确保已经引入xstream 的jar 包
  64.      * 以及类上面使用了@XStreamAlias("你定义的")；
  65.      * @param poClass
  66.      * @param xml
  67.      * @return
  68.      */
  69.     @SuppressWarnings("unchecked")
  70.     public static <T> T xmlToPojo(Class<T> poClass,String xml) {
  71.  
  72.         XStream xstream =new XStream();
  73.         xstream.processAnnotations(poClass);
  74.         xstream.processAnnotations(getInnerClasses(poClass));
  75.         return (T)xstream.fromXML(xml);
  76.  
  77.     }
  78.  
  79.     /**
  80.      * 将inputstream转换为 pojo 对象
  81.      * 确保已经引入xstream 的jar 包
  82.      * 以及类上面使用了@XStreamAlias("你定义的")；
  83.      * @param poClass
  84.      * @param xml
  85.      * @return
  86.      */
  87.     @SuppressWarnings("unchecked")
  88.     public static <T> T streamToPojo(Class<T> poClass,InputStream stream) {
  89.  
  90.         XStream xstream =new XStream();
  91.         xstream.processAnnotations(poClass);
  92.         xstream.processAnnotations(getInnerClasses(poClass));
  93.         return (T)xstream.fromXML(stream);
  94.  
  95.     }
  96.  
  97.     /**
  98.      * 使用common 包将流转换为字符串
  99.      * @param stream
  100.      * @return
  101.      * @throws Exception
  102.      */
  103.     public static String xmlStreamToString (InputStream stream) throws Exception{
  104.         String result =IOUtils.toString(stream, "utf-8");
  105.         return result;
  106.         }
  107.  
  108.     /**
  109.      *  获取 jaxp XML 解析器
  110.      *  位于javax 包中，Java 内置支持
  111.      * @throws ParserConfigurationException
  112.      */
  113.  
  114.     public static  DocumentBuilder getJaxpXmlBuilder() throws ParserConfigurationException {
  115.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  116.         DocumentBuilder builder = factory.newDocumentBuilder();
  117.         return builder;
  118.     }
  119.  
  120.     /**
  121.      * 获取xpath的实例对象
  122.      */
  123.     public static XPath getXpath() {
  124.           XPathFactory factory = XPathFactory.newInstance();
  125.           XPath xpath = factory.newXPath();
  126.           return xpath;
  127.     }
  128.  
  129.     /**
  130.      * jaxp 获取Document 对象,通过一个文件/流对象
  131.      * @throws ParserConfigurationException
  132.      * @throws IOException
  133.      * @throws SAXException
  134.      */
  135.     public static Document getJaxpDocument(DocumentBuilder builder,Object file) throws Exception {
  136.         DocumentBuilder xmlBuilder;
  137.         if((xmlBuilder=builder)==null) {
  138.             xmlBuilder=getJaxpXmlBuilder();
  139.         }
  140.         if(file instanceof File) {
  141.             return xmlBuilder.parse((File)file);
  142.         }else if(file instanceof InputStream) {
  143.             return xmlBuilder.parse((InputStream)file);
  144.         }else {
  145.             return null;
  146.         }
  147.     }
  148.  
  149.     /**
  150.      * dom4j
  151.      * 初始化，获取document 对象通过输入url的方式
  152.      * @param readObject 可以是流，也可以是文件，也可以是URL ，也可以是InputSource
  153.      * @return
  154.      * @throws DocumentException
  155.      */
  156.     public static org.dom4j.Document getDom4jDocument(Object readObject) throws DocumentException {
  157.         SAXReader reader =new SAXReader();
  158.         org.dom4j.Document document ;
  159.         if(readObject instanceof InputStream) {
  160.             document =reader.read((InputStream)readObject);
  161.         }else if(readObject instanceof File) {
  162.             document =reader.read((File)readObject);
  163.         }else if(readObject instanceof URL) {
  164.             document =reader.read((URL)readObject);
  165.         }else if(readObject instanceof InputSource){
  166.             document =reader.read((InputSource)readObject);
  167.         }else {
  168.             //没有匹配的的XML
  169.             document =null;
  170.         }
  171.  
  172.         return document;
  173.     }
  174.  
  175.     /**
  176.      * dom4j
  177.      * 获取根节点
  178.      * @param readObject可以是流，也可以是文件，也可以是URL ，也可以是InputSource
  179.      * @return
  180.      * @throws DocumentException
  181.      */
  182.     public static Element getDom4jRootElement(Object readObject) throws DocumentException {
  183.         org.dom4j.Document document = getDom4jDocument(readObject);
  184.         Element root = document.getRootElement();
  185.         return root;
  186.     }
  187.  
  188.     /**
  189.      * 将node 属性key value 存放到 Properties 中；eg:
  190.      * <test  name ="mytest" class="com.XX.XX">
  191.      * 将name ->mytest
  192.      * class -> com.XXX.XXX
  193.      * 存入Properties
  194.      *
  195.      */
  196.     public static Properties parseNodeAttributes(Node n) {
  197.           Properties attributes = new Properties();
  198.             NamedNodeMap attributeNodes = n.getAttributes();
  199.             //判断是否为空
  200.             if (attributeNodes != null) {
  201.               for (int i = 0; i < attributeNodes.getLength(); i++) {
  202.                 Node attribute = attributeNodes.item(i);
  203.                 attributes.put(attribute.getNodeName(), attribute.getNodeValue());
  204.               }
  205.             }
  206.             return attributes;
  207.     }
  208.  
  209.     /**
  210.      * 得到一个类的内部类
  211.      * @param clz
  212.      * @return
  213.      */
  214.     public static Class<?>[] getInnerClasses(Class<?> clz) {
  215.         Class<?>[] innerClasses = clz.getClasses();
  216.         if (innerClasses == null) {
  217.           return null;
  218.         }
  219.  
  220.         List<Class<?>> result = new ArrayList<>();
  221.         result.addAll(Arrays.asList(innerClasses));
  222.         for (Class<?> inner : innerClasses) {
  223.           Class<?>[] innerClz = getInnerClasses(inner);
  224.           if (innerClz == null) {
  225.             continue;
  226.           }
  227.  
  228.           result.addAll(Arrays.asList(innerClz));
  229.         }
  230.  
  231.         return result.toArray(new Class<?>[0]);
  232.       }
  233.  
  234. }

-----为了怕大家对xstream 注解不了解，大致就是这样的

  1. @XStreamAlias("xml")  //在xstream 注解转化时候，会将类名变为xml ，下面也一样
  2. public class Pojo {
  3.  
  4.     @XStreamAlias("namealia")
  5.     private String name;
  6.     @XStreamAlias("agelia")
  7.     private String age;
  8.     @XStreamAlias("lists")
  9.     private List<InnerPojo> list =new ArrayList<>();

xml转Map,对象，Map转xml，inputs tram 转xml 字符串的工具类方法的更多相关文章

  1. Js基础知识7-Es6新增对象Map和set数据结构

    前言 JavaScript中对象的本质是键值对的集合,ES5中的数据结构,主要是用Array和Object,但是键只能是字符串.为了弥补这种缺憾,ES6带来了一种新的数据结构Map. Map也是键值对 ...

  2. Es6中Map对象和Set对象的介绍及应用

    map和set的方法,工作中有使用到,所以学习一下: Map 对象 Map 对象保存键值对.任何值(对象或者原始值) 都可以作为一个键或一个值. var myMap = new Map(); myMa ...

  3. JavaScript基础对象---Map

    一.创建Map对象 Map 对象保存键值对.任何值(对象或者原始值) 都可以作为一个键或一个值 1.构造函数 语法:new Map([iterable])参数:         iterable  可 ...

  4. java 如何遍历Map对象

    内容介绍 在java中遍历Map对象的方法. Map对象 Map<String,Object> map = new HashMap<>(); map.put("xia ...

  5. JS中的Map对象

    1,js创建map对象 var map = new Map(); 2.将键值对放入map对象 map.set("key",value) map.set("key1&quo ...

  6. Map 集合 和 String 字符串相互转换工具类

    package com.skynet.rimp.common.utils.util; import java.util.Arrays; import java.util.HashMap; import ...

  7. Jackson 框架JSON、XML、List、Map直接相互转换

    博客分类: json   参考:http://www.cnblogs.com/hoojo/archive/2011/04/22/2024628.html 在其基础上做了稍微调整 详情见附件 jacks ...

  8. Xml格式数据转map工具类

    前言[ 最近在写一个业务,由于调UPS物流的接口返回的是一个xml格式的数据结果,我现在要拿到xml中某个节点的值,而这个xml数据是多节点多层级的,并且这某个节点的值有可能只有一条值,有可能有多条, ...

  9. JSON，Bean，XML，List，Map

    http://blog.csdn.net/superit401/article/details/51728929 JSON-lib这个Java类包用于把bean,map和XML转换成JSON并能够把J ...

随机推荐

  1. jquery循环方法

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  2. centos磁盘空间重新分配

    将/home目录压缩一部分空间到/ ref: https://serverfault.com/a/811124/434124 https://stackoverflow.com/a/19969471/ ...

  3. 运维中的日志切割操作梳理（Logrotate/python/shell脚本实现）(转)

    对于Linux系统安全来说,日志文件是极其重要的工具.不知为何,我发现很多运维同学的服务器上都运行着一些诸如每天切分Nginx日志之类的CRON脚本,大家似乎遗忘了Logrotate,争相发明自己的轮 ...

  4. colgroup中col定义表格单元格宽度

    colgroup中可以使用col来定义表格单元格宽度,可以使用像素(数字),百分比,我们来具体看看有什么不同. 先看一个最基本的:用像素(数字)表示,因为table有个宽度,这里表示占比 <ht ...

  5. 创建一个Maven Web应用程序

    1 在Eclipes创建maven,首先File new ,在other 中找到Maven,Maven Project,下一步选择WebApp,创建Maven工程名字,完成 2 在新建的Maven工程 ...

  6. SQL Server 利用Profiler观察执行计划是否重用时SP:Cachemiss，SP:CacheInsert以及SP:CacheHit的含义

    本文出处:http://www.cnblogs.com/wy123/p/6913055.html 执行计划的缓存与重用 在通过SQL Profile观察一个SQL语句或者存储过程是否有可用的缓存执行计 ...

  7. Redis Cluster 添加/删除 完整折腾步骤

    Redis还是挺好玩的,今天测试了集群的添加.删除节点.重分配slot等.更深入的理解redis的游戏规则.步骤繁多,但是详细. 环境解释: 我是在一台Centos 6.9上测试的,各个redis节点 ...

  8. Redux DevTools浏览器插件调试redux

    与redux的Devtools模块不同,该工具主要依赖浏览器插件完成.模式也比Devtools简单点. redux-devtools 是一个非常棒的工具,它可以让你实时的监控Redux的状态树的Sto ...

  9. ServiceWorker.state

    [ServiceWorker.state] ServiceWorker.state The state read-only property of the ServiceWorker interfac ...

  10. mysql 多行合并一行

    SELECT `w`.`id` AS `id`, `w`.`phone` AS `phone`, `w`.`belong_id` AS `belong_id`, `w`.`name` AS `name ...