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,至于服务端的写法,和客户端的写法类似。
不完整的地方,还请前辈们指点