服务器模拟数据并封装成成XML发送到客服端

这个程序是源于我的一个智能家居项目，需要将传感器（sensor）接收过来的数据，通过ZigBee模块发送到客户端，并在客户端的web页面展示。

1. 服务端线程，用于模拟数据，封装成xml格式，通过socket通信发送给客户端

package com.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.StringReader;
import java.net.ServerSocket;
import java.net.Socket;

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

import com.client.Sensor;

public class ServerThread implements Runnable {

    private final static int PORT = 3831;// 端口号
    private static ServerSocket serverSocket;
    private static Socket socket = null;
    private BufferedReader bufferedReader = null;
    private PrintStream print = null;
    Sensor sensor = new Sensor();

    public ServerThread() throws IOException {
        // TODO Auto-generated constructor stub
        serverSocket = new ServerSocket(PORT);
        socket = serverSocket.accept();//阻塞等待
        bufferedReader = new BufferedReader(new InputStreamReader(
                socket.getInputStream()));
    }

    public static void main(String[] args) throws IOException {
        new Thread(new ServerThread()).start();
    }

    /**
     * 解析xml成javabean对象，并填充javabean属性
     * @param xml
     * @param obj
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <Javebean> Javebean parseXML(String xml, Class<Javebean> obj) {
        Javebean javebean = null;
        try {
            //获得JAXBContext实例，用于实现xml和java树之间的互转
            JAXBContext jaxbContext = JAXBContext.newInstance(obj);
            //创建解组器对象
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            //将字符串格式的xml解析成对象，并填充相应的属性
            javebean = (Javebean) unmarshaller.unmarshal(new StringReader(xml));
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return javebean;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub

        String receivedXML = null;//用于接收xml,每次接收完会清空
        synchronized (this) {
            try {
                while(true)
                {
                    //读取发送过来的xml
                    receivedXML = bufferedReader.readLine();
                    //将获取的xml解析成sensor类，并填充属性
                    Sensor sensor = parseXML(receivedXML,Sensor.class);
                    //获得数据
                    System.out.println(sensor.getSensor_id()+" "+sensor.getCurrent_concentrations()+" "+sensor.getThreshold());
                }               
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }   
        }

    }
}

1. 客服端线程，用于接收来自客户端的xml格式数据，并解析成javabean，通过操作javabean对象来获取数据

package com.client;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlRootElement;

public class ClientThread implements Runnable{

    private final String URL = "127.0.0.1";//ip地址
    private final int PORT = 3831;//端口号
    private Socket socket = null;
    private PrintWriter printWriter  = null;
    Sensor sensor = new Sensor();

    public ClientThread() throws IOException
    {
        socket = new Socket(URL,PORT);
        printWriter = new PrintWriter(socket.getOutputStream(),true);
    }
    /**
     * 主入口函数
     * @param args
     */
    public static void main(String[] args) {
        try {
            //启动线程
            new Thread(new ClientThread()).start();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //封装成xml
    public static String getXML(Object obj,String encoding)
    {
        String getedXML = "";
        try {
            //获得JAXBContext实例，用于实现xml和java树之间的互转
            JAXBContext jaxbContext = JAXBContext.newInstance(obj.getClass());
            //创建编组器对象
            Marshaller marshaller = jaxbContext.createMarshaller();
            //设置转成xml自动格式化
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            //设置编码
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "utf-8");
            StringWriter stringWriter = new StringWriter();
            //将obj转成xml，并写入一个字符流
            marshaller.marshal(obj, stringWriter);
            getedXML = stringWriter.toString();
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return getedXML;
    }

    /**
     * 获取min,到max范围的随机整数
     * @param min
     * @param max
     * @return
     */
    public static int getInt(int min,int max)
    {
        Random random = new Random();
        int getedInt = random.nextInt(max)%(max-min+1) + min;
        return getedInt;
    }
   /**
    * 获取min,到max范围的随机浮点数
    * @param min
    * @param max
    * @return
    */
    public static float getFloat(float min,float max)
    {
        Random random = new Random();
        float getedFloat = random.nextFloat()*(max-min) + min;
        return getedFloat;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

            while(true)
            {
                synchronized (this) {
                    try {
                        Thread.sleep(3000);//3000毫秒发一次
                        //填充数据
                        sensor.setSensor_id(getInt(1,2));
                        sensor.setCurrent_concentrations(getFloat(10f,50f));
                        sensor.setThreshold(30.5f);

                        //取出换行符
                        String sendedXML = getXML(sensor,"utf-8");
                        Pattern p = Pattern.compile("\n");
                        Matcher m = p.matcher(sendedXML);
                        sendedXML = m.replaceAll("  ");
                        //发送xml到服务器
                        printWriter.println(sendedXML);

                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }           
        }       
    }   
}

1. javabean类，用于填充数据

package com.client;

import java.io.Serializable;

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


@XmlAccessorType(XmlAccessType.FIELD)  
@XmlRootElement(name = "sensor")//不可少，标识根元素
@XmlType(propOrder = { "sensor_id", "current_concentrations", "threshold"})  
public class Sensor implements Serializable{

    @XmlElement(required = true) 
    private int sensor_id;//传感器id
    @XmlElement(required = true) 
    private float current_concentrations;//当前浓度
    @XmlElement(required = true) 
    private float threshold;//正常浓度

    public int getSensor_id() {
        return sensor_id;
    }
    public void setSensor_id(int sensor_id) {
        this.sensor_id = sensor_id;
    }
    public float getCurrent_concentrations() {
        return current_concentrations;
    }
    public void setCurrent_concentrations(float current_concentrations) {
        this.current_concentrations = current_concentrations;
    }
    public float getThreshold() {
        return threshold;
    }
    public void setThreshold(float threshold) {
        this.threshold = threshold;
    }
    @Override
    public String toString() {
        return "Sensor [sensor_id=" + sensor_id + ", current_concentrations="
                + current_concentrations + ", threshold=" + threshold + "]";
    }

}

1. 4.