第一步：新建一个java project,增加一个User类 如下图：
第二步：编写User类的代码，代码如下所示：
package com.socket.entity;
import java.io.Serializable;
/**
* 用户实体类
*
* @author lfc 备注：如果这个实体类需要通过socket类来实现传递，必须实现 Serializable接口
*/
public class User implements Serializable {
private static final long serialVersionUID = -8828187863940569914L;
private long id;
private String name;
private String password;
private int age;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public User() {
}
public User(long id, String name, String password, int age) {
this.id = id;
this.name = name;
this.password = password;
this.age = age;
}
}
第三步，修改服务器端后的代码如下：
package com.socket.server;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import com.socket.entity.User;
/**
* 服务器端
*
* @author lfc 对于这个客户端以及服务端，运行的时候，必须先服务端开始运行起来，开始监听客户端的程序请求
* 缺点：如果是登录程序中只能监听一个用户登录程序就会进入死亡转态了
*/
public class SocketServer {
public static void main(String[] args) {
System.out.println("服务器端准备好监听客户端的请求了。。。");
try {
// 1：创建一个服务端的ServerScoket,绑定端口开始监听
ServerSocket serverScoket = new ServerSocket(8800);
// 2:使用accept()方法阻塞等待连接，获得新的连接
Socket socket = serverScoket.accept();
// 3:获得输入流
InputStream is = socket.getInputStream();
// 包装下变成字符流，实现可以对对象进行反序列话操作
ObjectInputStream ois=new ObjectInputStream(is);
//创建输出流，用来给客户端提示的响应信息
OutputStream os = socket.getOutputStream();
PrintWriter pw = new PrintWriter(os);
// 4:读取对象，获得对象
User user=(User)ois.readObject();
System.out.println("编号："+user.getId());
System.out.println("年龄："+user.getAge());
System.out.println("姓名："+user.getName());
System.out.println("密码："+user.getPassword());
//给客户端的回应信息
String response="客户端已经收到你们的信息了,Success";
pw.write(response);
pw.flush();
// 5:关闭资源,注意，关闭的时候，要从底部开始往上依次关闭，顺序不能错！
os.close();
pw.close();
ois.close();
is.close();
socket.close();
serverScoket.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println("本次服务端监听结束！。。。");
}
}
第四步，修改客户端的代码后如下：
package com.socket.client;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import com.socket.entity.User;
/**
* 客户端
*
* @author lfc
*
*/
public class loginClient {
public static void main(String[] args) throws UnknownHostException {
try {
// 1,创建serverScoket客户端，绑定服务器端的ip以及端口
Socket scoket = new Socket("localhost", 8800);
// 2,得到scoket读写流
OutputStream os = scoket.getOutputStream();
// 获得对象输出流，可以对对象进行序列化操作
ObjectOutputStream oos=new ObjectOutputStream(os);
//输入流
InputStream is=scoket.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(is));
// 3,利用一定的协议对scoket中的对读写操作
PrintWriter pw = new PrintWriter(os);
User user=new User();
user.setId(1);
user.setAge(19);
user.setName("tom");
user.setPassword("AAbb123");
oos.writeObject(user);
//需要先关闭，一定要记得先关闭
scoket.shutdownOutput();
//接收并显示收到服务器端返回的信息！
String answer = null;
while (!((answer = br.readLine()) == null)) {
System.out.println("我是服务器端接收并且给返回的信息：\n" + answer);
}
// 4,关闭流
is.close();
oos.close();
br.close();
os.close();
scoket.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("客户端请求完毕！");
}
}
第五步：运行服务器端的代码，控制台输出的内容如下：
可以看见，运行服务器端后，服务器处于监听转态
第六步：运行客户端的代码，结果如下图：
此时客户端收到来自服务器的回应，并且显示success
第七步，再次查看服务器端的控制台输出的内容如下：
服务器端，收到来自客户端的一个对象，并且实现面向对象编程了。