- 服务器端创建一个 ServerSocket（服务器端套接字），调用 accept() 方法等待客户端来连接。
- 客户端程序创建一个 Socket，请求与服务器建立连接。
- 服务器接收客户的连接请求，同时创建一个新的 Socket 与客户建立连接，服务器继续等待新的请求。
ServerSocket 类
ServerSocket 类是与 Socket 类相对应的用于表示通信双方中的服务器端，用于在服务器上开一个端口，被动地等待数据（使用 accept() 方法）并建立连接进行数据交互。
服务器套接字一次可以与一个套接字连接，如果多台客户端同时提出连接请求，服务器套接字会将请求连接的客户端存入队列中，然后从中取出一个套接字与服务器新建的套接字连接起来。若请求连接大于最大容纳数，则多出的连接请求被拒绝；默认的队列大小是 50。
下面简单介绍一下 ServerSocket 的构造方法和常用方法。
ServerSocket 的构造方法
ServerSocket 的构造方法如下所示。
- ServerSocket()：无参构造方法。
- ServerSocket(int port)：创建绑定到特定端口的服务器套接字。
- ServerSocket(int port,int backlog)：使用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口。
- ServerSocket(int port,int backlog,InetAddress bindAddr)：使用指定的端口、监听 backlog 和要绑定到本地的 IP 地址创建服务器。
在上述方法的参数中 port 指的是本地 TCP 端口，backlog 指的是监听 backlog，bindAddr 指的是要将服务器绑定到的 InetAddress。
创建 ServerSocket 时可能会拋出 IOException 异常，所以要进行异常捕捉。如下所示为使用 8111 端口的 ServerSocket 实例代码。
try
{
ServerSocket serverSocket=new ServerSocket(8111);
}
catch(IOException e)
{
e.printStackTrace();
}
ServerSocket 的常用方法
ServerSocket 的常用方法如下所示。
- Server accept()：监听并接收到此套接字的连接。
- void bind(SocketAddress endpoint)：将 ServerSocket 绑定到指定地址（IP 地址和端口号）。
- void close()：关闭此套接字。
- InetAddress getInetAddress()：返回此服务器套接字的本地地址。
- int getLocalPort()：返回此套接字监听的端口。
- SocketAddress getLocalSoclcetAddress()：返回此套接字绑定的端口的地址，如果尚未绑定则返回 null。
- int getReceiveBufferSize()：获取此 ServerSocket 的 SO_RCVBUF 选项的值，该值是从 ServerSocket 接收的套接字的建议缓冲区大小。
调用 accept() 方法会返回一个和客户端 Socket 对象相连接的 Socket 对象，服务器端的 Socket 对象使用 getOutputStream() 方法获得的输出流将指定客户端 Socket 对象使用 getInputStream() 方法获得那个输入流。同样，服务器端的 Socket 对象使用的 getInputStream() 方法获得的输入流将指向客户端 Socket 对象使用的 getOutputStream() 方法获得的那个输出流。也就是说，当服务器向输出流写入信息时，客户端通过相应的输入流就能读取，反之同样如此，整个过程如图 1 所示。
图1 服务器与客户端连接示意图
例 1
了解上面的基础知识后，下面使用 ServerSocket 类在本机上创建一个使用端口 8888 的服务器端套接字，实例代码如下所示。
public static void main(String[] args)
{
try
{
//在8888端口创建一个服务器端套接字
ServerSocket serverSocket=new ServerSocket(8888);
System.out.println("服务器端Socket创建成功");
while(true)
{
System.out.println("等待客户端的连接请求");
//等待客户端的连接请求
Socket socket=serverSocket.accept();
System.out.println("成功建立与客户端的连接");
}
}
catch(IOException e)
{
e.printStackTrace();
}
}
如上述代码所示，在成功建立 8888 端口的服务器端套接字之后，如果没有客户端的连接请求，则 accept() 方法为空，所以不会输出“成功建立与客户端的连接”，运行结果如下所示。
服务器端S.ocket创違成功 等待客户端的连接请求
Socket 类
Socket 类表示通信双方中的客户端，用于呼叫远端机器上的一个端口，主动向服务器端发送数据（当连接建立后也能接收数据）。下面简单介绍一下 Socket 类的构造方法和常用方法。
Socket 的构造方法
Socket 的构造方法如下所示。
- Socket()：无参构造方法。
- Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口。
- Soclcet(InetAddress address,int port,InetAddress localAddr,int localPort)：创建一个套接字并将其连接到指定远程地址上的指定远程端口。
- Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口。
- Socket(String host,int port,InetAddress localAddr,int localPort)：创建一个套接字并将其连接到指定远程地址上的指定远程端口。Socket 会通过调用 bind() 函数来绑定提供的本地地址及端口。
在上述方法的参数中，address 指的是远程地址，port 指的是远程端口，localAddr 指的是要将套接字绑定到的本地地址，localPort 指的是要将套接字绑定到的本地端口。
Socket 的常用方法
Socket 的常用方法如下所示。
- void bind(SocketAddress bindpoint)：将套接字绑定到本地地址。
- void close()：关闭此套接字。
- void connect(SocketAddress endpoint)：将此套接字连接到服务器。
- InetAddress getInetAddress()：返回套接字的连接地址。
- InetAddress getLocalAddress()：获取套接字绑定的本地地址。
- InputStream getInputStream()：返回此套接字的输入流。
- OutputStream getOutputStream()：返回此套接字的输出流。
- SocketAddress getLocalSocketAddress()：返回此套接字绑定的端点地址，如果尚未绑定则返回 null。
- SocketAddress getRemoteSocketAddress()：返回此套接字的连接的端点地址，如果尚未连接则返回 null。
- int getLoacalPort()：返回此套接字绑定的本地端口。
- intgetPort()：返回此套接字连接的远程端口。
例 2
编写 TCP 程序，包括一个客户端和一个服务器端。要求服务器端等待接收客户端发送的内容，然后将接收到的内容输出到控制台并做出反馈。
(1) 创建一个类作为客户端，首先在 main() 方法中定义一个 Socket 对象、一个 OutputStream 对象和一个 InputStream 对象并完成初始化。接着定义服务器端的 IP 地址和端口号，代码如下所示。
public static void main(String[] args)
{
Socket socket=null;
OutputStream out=null;
InputStream in=null;
String serverIP="127.0.0.1"; //服务器端 IP 地址
int port=5000; //服务器端端口号
}
(2) 建立与服务器端的连接并将数据发送到服务器端，代码如下所示。
socket=new Socket(serverIP,port); //建立连接
out=socket.getOutputStream(); //发送数据
out.write("我是客户端数据 ".getBytes());
(3) 从输入流中读出服务器的反馈信息并输出到控制台，代码如下所示。
byte[] b=new byte[1024];
in=socket.getInputStream();
int len=in.read(b);
System.out.println(" 服务器端的反馈为："+new String(b,0,len));
(4) 关闭输入/输出流以及 Socket 对象，代码如下所示。
in.close(); out.close(); socket.close();
(5) 创建一个类作为服务器端，编写 main() 方法，创建 ServerSocket、Socket、InputStream、OutputStream 以及端口号并初始化，代码如下所示。
ServerSocket ServerSocket=null; Socket socket=null; InputStream in=null; OutputStream out=null; int port=5000;
(6) 开启服务器并接收客户端发送的数据，代码如下所示。
ServerSocket=new ServerSocket(port); //创建服务器套接字
System.out.println("服务器开启，等待连接。。。");
socket=ServerSocket.accept(); //获得连接
//接收客户端发送的内容
in=socket.getInputStream();
byte[] b=new byte[1024];
int len=in.read(b);
System.out.println("客户端发送的内容为："+new String(b,0,len));
(7) 使用输出流对象将信息反馈给客户端，代码如下所示。
out=socket.getOutputStream();
out.write("我是服务器端".getBytes());
(8) 关闭输入/输出流、Socket 对象以及 ServerSocket 对象，代码如下所示。
in.close(); out.close(); ServerSocket.close(); socket.close();
(9) 运行服务器端程序代码，运行结果如下所示。
服务器开启，等待连接。。。
(10) 为了使程序的结果更加清晰，在步骤 (2) 的代码最后加入一句代码“Thread.sleep(1000);”。接着运行客户端程序代码，刚开始会出现如下所示的运行结果。
服务器开启，等待连接。。。 客户端发送的内容为：我是客户端数据
紧接着又会出现如下所示的运行结果。
客户端的反馈为：我是服务器端
客户端与服务器端的简单通信
在了解 TCP 通信中 ServerSocket 类和 Socket 类的简单应用之后，本节将编写一个案例实现客户端向服务器发送信息，服务器读取客户端发送的信息，并将读取的数据写入到数据流中。
首先来看一下客户端的代码，如下所示：
public class SocketDemo
{
public static void main(String[] args)
{
Socket socket=null;
PrintWriter out=null;
BufferedReader in=null;
String serverIP="127.0.0.1"; //服务器端ip地址
int port=5000; //服务器端端口号
try
{
socket=new Socket(serverIP,port);
in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
out=new PrintWriter(socket.getOutputStream(),true);
while(true)
{
int number=(int)(Math.random()*10)+1;
System.out.println("客户端正在发送的内容为："+number);
out.println(number);
Thread.sleep(2000);
}
}
catch(IOException | InterruptedException e)
{
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
如上述代码所示，客户端代码主要是使用 Socket 连接 IP 为 127.0.0.1（本机）的 5000 端口。在建立连接之后将随机生成的数字使用 PrintWriter 类输出到套接字。休眠 2 秒后，再次发送随机数，如此循环。
再来看一个服务器端的代码，如下所示：
package ch16;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketDemoServer1
{
public static void main(String[] args)
{
ServerSocket serverSocket=null;
Socket clientSocket=null;
BufferedReader in=null;
int port=5000;
String str=null;
try
{
serverSocket=new ServerSocket(port); //创建服务器套接字
System.out.println("服务器开启，等待连接。。。");
clientSocket=serverSocket.accept();// 获得链接
//接收客户端发送的内容
in=new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
while(true)
{
str=in.readLine();
System.out.println("客户端发送的内容为："+str);
Thread.sleep(2000);
}
}
catch(IOException | InterruptedException e)
{
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
如上述代码所示，服务器端与客户端代码类似，首先使用 ServerSocket 在 IP为127.0.0.1（本机）的 5000 端口建立套接字监听。在 accept() 方法接收到客户端的 Socket 实例之后调用 BufferedReader 类的 readLine() 方法，从套接字中读取一行作为数据，再将它输出到控制后休眠 2 秒。
要运行本案例，必须先执行服务器端程序，然后执行客户端程序。客户端每隔 2 秒向服务器发送一个数字，如下所示。
客户端正在发送的内容为：10 客户端正在发送的内容为：5 客户端正在发送的内容为：10 客户端正在发送的内容为：4 客户端正在发送的内容为：3
服务器端会将客户端发送的数据输出到控制台，如下所示。
服务器幵启，等待连接。。。 客户端发送的内容为：7 客户端发送的内容为：2 客户端发送的内容为：10 客户端发送的内容为：5 客户端发送的内容为：10
……
传输对象数据
经过前面的学习，掌握了如何在服务器开始一个端口监听套接字，以及如何在客户端连接服务器，发送简单的数字。本次案例将实现如何在客户端发送一个对象到服务器端，服务器如何解析对象中的数据。
例 3
第一步是创建用于保存数据的类。这里使用的 User 类是一个普通的类，包含 name 和 password 两个成员。由于需要序列化这个对象以便在网络上传输，所以需要实现 java. io.Serializable 接 P。
User 类的代码如下：
package ch16;
public class User implements java.io.Serializable
{
private String name;
private String password;
public User(String name,String password)
{
this.name=name;
this.password=password;
}
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;
}
}
接下来编写服务器端的代码。服务器的作用是接收客户端发送过来的数据，将数据转换成 User 对象并输出成员信息，然后对 User 对象进行修改再输出给客户端。
服务器端 MyServer 类的实现代码如下：
package ch16;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class MyServer
{
public static void main(String[] args) throws IOException
{
// 监听10000端口
ServerSocket server=new ServerSocket(10000);
while(true)
{
//接收客户端的连接
Socket socket=server.accept();
//调用客户端的数据处理方法
invoke(socket);
}
}
private static void invoke(final Socket socket) throws IOException
{
//开启一个新线程
new Thread(new Runnable()
{
public void run()
{
//创建输入流对象
ObjectInputStream is=null;
//创建输出流对象
ObjectOutputStream os=null;
try
{
is=new ObjectInputStream(socket.getInputStream());
os=new ObjectOutputStream(socket.getOutputStream());
//读取一个对象
Object obj = is.readObject();
//将对象转换为User类型
User user=(User) obj;
//在服务器端输出name成员和password成员信息
System.out.println("user: "+user.getName()+"/"+user.getPassword());
//修改当前对象的name成员数据
user.setName(user.getName()+"_new");
//修改当前对象的password对象数据
user.setPassword(user.getPassword()+"_new");
//将修改后的对象输出给客户端
os.writeObject(user);
os.flush();
}
catch(IOException|ClassNotFoundException ex)
{
ex.printStackTrace();
}
finally
{
try
{
//关闭输入流
is.close();
//关闭输出流
os.close();
//关闭客户端
socket.close();
}
catch(Exception ex){}
}
}
}).start();
}
}
如上述代码所示，在服务器端分别使用 ObjectInputStream 和 ObjectOutputStream 来接收和发送 socket 中的 InputStream 和OutputStream，然后转换成 User 对象。
客户端需要连接服务器，接收服务器输出的数据并解析，同时需要创建 User 对象并发给服务器。客户端 MyClient 类的实现代码如下：
package ch16;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
public class MyClient
{
public static void main(String[] args) throws Exception
{
//循环100次
for(int i=0;i<100;i++)
{
//创建客户端Socket
Socket socket=null;
//创建输入流
ObjectOutputStream os=null;
//创建输出流
ObjectInputStream is=null
try
{
//连接服务器
socket=new Socket("localhost",10000);
//接收输出流中的数据
os=new ObjectOutputStream(socket.getOutputStream());
//创建一个User对象
User user=new User("user_"+i,"password_"+i);
//将User对象写入输出流
os.writeObject(user);
os.flush();
//接收输入流中的数据
is=new ObjectInputStream(socket.getInputStream());
//读取输入流中的数据
Object obj=is.readObject();
//如果数据不空则转换成User对象，然后输出成员信息
if(obj!=null)
{
user=(User) obj;
System.out.println("user: "+user.getName()+"/"+user.getPassword());
}
}
catch(IOException ex)
{
ex.printStackTrace();
}
finally
{
try
{
//关闭输入流
is.close();
//关闭输出流
os.close();
//关闭客户端
socket.close();
}
catch(Exception ex) {}
}
}
}
}
仔细观察上述代码可以发现，客户端与服务器端的代码类似，同样使用 ObjectOutputStream 和 ObjectInputStream 来处理数据。
先运行服务器端程序 MyServer，再运行客户端程序 MyClient。此时将在客户端看到下所示的输出。
user:user_86_nevj/password_86_new user:user_87_new/password_87_new user:user_88_new/password_88_new user:user_89_new/password_89_new user:user_90_new/password_90_new user:user_91_new/password_91_new user:user_92_new/password_92_new user:user_93_new/password_93_new user:user_94_new/password_94_new user:user_95_new/password_95_new user:user_96_new/password_96_new user:user_97_new/password_97_new user:user_98_new/password_98_new user:user_99_new/password_99_new
服务器端的输出如下所示。
user:user_86/password_86 user:user_87/password_87 user:user_88/password_88 user:user_89/password_89 user:user_90/password_90 user:user_91/password_91 user:user_92/password_92 user:user_93/password_93 user:user_94/password_94 user:user_95/password_95 user:user_96/password_96 user:user_97/password_97 user:user_98/password_98 user:user_99/password_99
原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/21978.html