Android 客户端使用udp发送请求并解析xml

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_26841579/article/details/82456111

1,UDP请求客户端

package udp;

/**
 * <author> cwj
 * <time>  2018/8/27 15:29
 * <version>
 * <desc>UDP客户端
 **/
public class UdpClient {

    public static void main(String[] args) {
    //请求时把实体类转成xml数据
        UserBean userBean=new UserBean();
        userBean.setName("小明");
        userBean.setAge(15);
        userBean.setSex("男");

        String xml= XMLUtils.convertToXml(userBean);
        System.out.println(xml);


        SendThred send_receive=new SendThred("192.168.0.107",9090,xml);
        send_receive.start();//请求线程
        ReceiveThred receiveThred=new ReceiveThred(9090, new IReceiveData() {
            @Override
            public String receiveXML(String xml) {
                xml.trim();//接收 服务端返回的数据
                   User u2= (User) XMLUtils.convertXmlStrToObject(User.class,xml.trim());
                   return null;
            }
        });
        receiveThred.start();
    }




}

2，发送

package udp;




import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;

/**
 * <author> cwj
 * <time>  2018/8/27 15:43
 * <version>
 * <desc>发送接收线程类
 **/
public class SendThred extends Thread {
    public String data;
    public String ip;
    private int port;
    private int Timeout=5000;//设置超时时间，5秒

    public SendThred(String ip, int port, String data) {
        this.data = data;
        this.ip = ip;
        this.port = port;
    }

    @Override
    public void run() {
        //发送
        DatagramSocket socket = null;
        try {
        socket = new DatagramSocket();
         socket.setSoTimeout(Timeout);//设置超时时间
        byte[] buf = data.getBytes();
        InetAddress address = InetAddress.getByName(ip);
        DatagramPacket packet = new DatagramPacket(buf, buf.length, address, port);
        socket.send(packet);

         log.print("发送--"+new String(packet.getData(), "utf-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }



}

3，接收

package udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * <author> cwj
 * <time>  2018/8/27 16:48
 * <version>
 * <desc>接收
 **/
public class ReceiveThred extends Thread  {
    public int port;
    private IReceiveData iReceiveData;
    private int Timeout=5000;//设置超时时间，5秒
    public ReceiveThred(  int port, IReceiveData iReceiveData) {
        this.port = port;
        this.iReceiveData = iReceiveData;
    }

    @Override
    public void run() {
        DatagramSocket socket=null;
        try {
            socket = new DatagramSocket(port);
            socket.setSoTimeout(Timeout);//设置超时时间
            //准备空的数据包用于存放数据。
            byte[] buf = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length); // 1024
            //调用udp的服务接收数据
            socket.receive(datagramPacket); //receive是一个阻塞型的方法，没有接收到数据包之前会一直等待。 数据实际上就是存储到了byte的自己数组中了。
            String backMes = new String(datagramPacket.getData(), "gbk");
            System.out.print("接收端接收到服务端的数据"+backMes);
//            User u2= (User) XMLUtils.convertXmlStrToObject(User.class,backMes.trim());
            iReceiveData.receiveXML(backMes);
            //关闭资源
            socket.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }


}

package udp;

public interface IReceiveData {
    //获取XML
    String receiveXML(String xml);
}

4，解析XML 用jdk自带原生解析

      User u2= (User) XMLUtils.convertXmlStrToObject(User.class,xml.trim());

5，工具类

package udp;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.*;

/**
 * <author> cwj
 * <time>  2018/8/27 18:07
 * <version>
 * <desc>XML
 **/
public class XMLUtils {

    /**
     * 将对象直接转换成String类型的 XML输出
     *
     * @param obj
     * @return
     */
    public static String convertToXml(Object obj) {
        // 创建输出流
        StringWriter sw = new StringWriter();
        try {
            // 利用jdk中自带的转换类实现
            JAXBContext context = JAXBContext.newInstance(obj.getClass());

            Marshaller marshaller = context.createMarshaller();
            // 格式化xml输出的格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            // 将对象转换成输出流形式的xml
            marshaller.marshal(obj, sw);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return sw.toString();
    }

    /**
     * 将对象根据路径转换成xml文件
     *
     * @param obj
     * @param path
     * @return
     */
    public static void convertToXml(Object obj, String path) {
        try {
            // 利用jdk中自带的转换类实现
            JAXBContext context = JAXBContext.newInstance(obj.getClass());

            Marshaller marshaller = context.createMarshaller();
            // 格式化xml输出的格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            // 将对象转换成输出流形式的xml
            // 创建输出流
            FileWriter fw = null;
            try {
                fw = new FileWriter(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
            marshaller.marshal(obj, fw);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("unchecked")
    /**
     * 将String类型的xml转换成对象
     */
    public static Object convertXmlStrToObject(Class clazz, String xmlStr) {
        Object xmlObject = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            // 进行将Xml转成对象的核心接口
            Unmarshaller unmarshaller = context.createUnmarshaller();
            StringReader sr = new StringReader(xmlStr);
            xmlObject = unmarshaller.unmarshal(sr);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return xmlObject;
    }

    @SuppressWarnings("unchecked")
    /**
     * 将file类型的xml转换成对象
     */
    public static Object convertXmlFileToObject(Class clazz, String xmlPath) {
        Object xmlObject = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            FileReader fr = null;
            try {
                fr = new FileReader(xmlPath);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            xmlObject = unmarshaller.unmarshal(fr);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return xmlObject;
    }


}

6,解析的时候注意实体类的注解：

package udp;

import java.io.Serializable;
import java.util.Date;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 * 
 * @author Steven
 * 
 */
@XmlAccessorType(XmlAccessType.FIELD)
//根部
@XmlRootElement(name = "User")
// 
@XmlType(propOrder = { 
        "userId", 
        "userName", 
        "password", 
        "birthday", 
        "money", 
})
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    // �û�Id
    private int userId;
    // �û���
    private String userName;
    // �û�����
    private String password;
    // �û�����
    private Date birthday;
    // �û�Ǯ��
    private double money;

    public User() {
        super();
    }

    public User(int userId, String userName, String password, Date birthday,
            double money) {
        super();
        this.userId = userId;
        this.userName = userName;
        this.password = password;
        this.birthday = birthday;
        this.money = money;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "User [birthday=" + birthday + ", money=" + money
                + ", password=" + password + ", userId=" + userId
                + ", userName=" + userName + "]";
    }

}

7，至于服务端的写法，和客户端的写法类似。
不完整的地方，还请前辈们指点