对象序列化在客户端和服务端传输实例

说明：本例通过一个学生Student实体类，这具类实现了Serializable类，一个客户端SocketDemo类，一个服务器端ServerSocketDemo类，还有一个SocketThread类，这个类继承了Thread类，可以实现服务器的多线程访问，一个xml文档储存了学生的信息，通过输入学生姓名和学科，来确定这个学生是否存在，应用上可以用这样的例子来验证用户登录。


1、首先创建一个实体Student类，这个类必须实现Serializable接口


import java.io.Serializable;

public class Student implements Serializable{

private int id;
private String name;
private String course;
private int score;

public Student(String name, String course) {
super();
this.name = name;
this.course = course;
}
public Student(String name, String course, int score) {
super();
this.name = name;
this.course = course;
this.score = score;
}
public Student() {
super();
}
public Student(int id, String name, String course, int score) {
super();
this.id = id;
this.name = name;
this.course = course;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}


2、定义客户端类

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;


public class SocketDemo {


public static void main(String[] args) {
OutputStream out=null;
InputStream in=null;
Socket socket=null;
try { //服务器地IP地址和端口号
socket = new Socket("127.0.0.1",9999);
out=socket.getOutputStream();
in=socket.getInputStream();
Scanner inpu = new Scanner(System.in);
System.out.println("请输入你要查询的姓名：");
String n= inpu.next();
System.out.println("请输入你要查询的学科：");
String c=inpu.next();
//新建一个学生对象
Student student = new Student(n,c);
//运用ObjectOutputStream把这个学生对象序列化
ObjectOutputStream objout= new ObjectOutputStream(out);
objout.writeObject(student);
socket.shutdownOutput();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String s=br.readLine();
System.out.println(s);

} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
out.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}


}
}


3、定义服务器端类


import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class ServerSocketDemo {


public static void main(String[] args) {

try {
ServerSocket ssocket = new ServerSocket(9999);
//通过死循还来确保服务器一直在运行
while(true){

Socket soc = ssocket.accept();
SocketThread socket = new SocketThread(soc);
socket.start();
}


} catch (IOException e) {
e.printStackTrace();
}
}


}


4、通过一个SocketThread类，确保服务器多线程

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;


public class SocketThread extends Thread {


private Socket socket;


public SocketThread(Socket socket) {
this.socket = socket;
}


public void run() {
try {
InputStream input = socket.getInputStream();
OutputStream output = socket.getOutputStream();
//把客户端传递过来的对象进行反序列化
ObjectInputStream objin = new ObjectInputStream(input);
//强转成student类
Student student = (Student) objin.readObject();
boolean t = deng(student);
if(t){
output.write("这个学生已经存在".getBytes());
}else{
output.write("这个学生不存在！".getBytes());
}
output.close();
socket.close();
} catch (Exception e) {
System.out.println("出错了！！");
e.printStackTrace();
}
}
//通过这个类判断xml文档里是否存在这个学生
public boolean deng(Student stu) {
Document doc = null;
SAXReader r = null;
Element root = null;

try {
r = new SAXReader();
doc = r.read(new FileInputStream("src/Student.xml"));
root = doc.getRootElement();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (DocumentException e) {
e.printStackTrace();
}
List<Element> list =root.elements("student");
for (Element st : list) {
List<Element> li=st.elements();
for (int i=0;i<li.size();i++) {
if(li.get(i).getText().equals(stu.getName())&&
li.get(i+1).getText().equals(stu.getCourse())){
return true;
}
}
}
return false;
}
}