Java의 소켓 프로그래밍 소개

이 글은 주로 자바 소켓 관련 지식을 소개합니다프로그래밍소개. 매우 훌륭하고 참고할 가치가 있습니다. 도움이 필요한 친구들이 참고할 수 있습니다.

자바 소켓 프로그래밍에는 두 가지 개념이 있습니다. 하나는 ServerSocket 입니다. 하나는 소켓입니다. 서버와 클라이언트는 Socket을 통해 연결을 맺고 통신을 할 수 있다. 먼저 ServerSocket은 서버 측의 특정 포트를 수신하여 클라이언트에 소켓이 있는 것을 확인하고 연결을 시도하면 해당 소켓의 연결 요청을 수락하고 서버 측에 해당 소켓을 설정하여 통신합니다. 그것으로. 이런 방식으로 두 개의 소켓이 있는데, 하나는 클라이언트용이고 다른 하나는 서버용입니다.

          소켓 간의 통신은 실제로 매우 간단합니다. 서버는 소켓의 출력 스트림에 무언가를 쓰고 클라이언트는 소켓의 입력 스트림을 통해 해당 콘텐츠를 읽을 수 있습니다. Socket과 Socket 사이에는 양방향 연결이 있으므로 클라이언트는 해당 Socket 출력 스트림에 내용을 쓸 수도 있고, 그런 다음 서버의 해당 Socket 입력 스트림에서 해당 콘텐츠를 읽을 수도 있습니다. 서버와 클라이언트 간의 통신에 대한 몇 가지 예를 살펴보겠습니다.

1. 클라이언트는 쓰고 서버는 읽습니다.

서버 코드

Java 코드

 public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
 Socket socket = server.accept(); 
 //跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。 
 Reader reader = new InputStreamReader(socket.getInputStream()); 
 char chars[] = new char[64]; 
 int len; 
 StringBuilder sb = new StringBuilder(); 
 while ((len=reader.read(chars)) != -1) { 
  sb.append(new String(chars, 0, len)); 
 } 
 System.out.println("from client: " + sb); 
 reader.close(); 
 socket.close(); 
 server.close(); 
 } 
 }

서버는 다음의 InputStream에서 데이터를 읽습니다. 소켓 작업도 차단됩니다. 입력 스트림에서 데이터를 읽지 않으면 클라이언트가 소켓 출력 스트림에 데이터를 쓰거나 소켓 출력 스트림을 닫을 때까지 프로그램이 그대로 유지됩니다. 물론 클라이언트의 소켓에도 마찬가지입니다. 작업이 완료된 후 전체 프로그램이 끝나기 전에 해당 리소스를 닫아야 합니다. 즉, 해당 IO 스트림과 소켓을 닫아야 합니다. ???? Out Through Out ‐oleps outceps out‐‐‐‐‐ 및  차단됩니다.

표준 작업의 경우(예: 입력 스트림), 이를 플러시하는 것을 기억하십시오. 이 방법으로만 서버가 클라이언트가 보낸 데이터를 받을 수 있습니다. 그렇지 않으면 두 당사자가 서로를 무기한 기다리게 될 수 있습니다. 이 문제는 나중에 클라이언트와 서버가 동시에 읽고 쓸 때 논의됩니다.

2. 클라이언트와 서버가 동시에 읽고 쓰기

앞에서 언급했듯이 소켓은 데이터를 동시에 보낼 수 있는 양방향 통신입니다.

서비스 측 코드 vjava code

public class Client { 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream()); 
 writer.write("Hello Server."); 
 writer.flush();//写完后要记得flush 
 writer.close(); 
 client.close(); 
 } 
 }

위 코드에서는 먼저 해당 리소스 파일에서 클라이언트가 보낸 데이터를 읽습니다. 실제로 위의 코드는 입력 스트림에서 데이터를 읽는 것이 차단 작업이기 때문에 예상대로 실행되지 않을 수 있습니다. 위의

while 루프
에서는 데이터를 읽을 때 루프 본문이 실행되고, 그렇지 않으면 차단됩니다. , 후속 쓰기 작업이 실행되지 않도록 합니다. 클라이언트의 해당 소켓이 닫히지 않는 한 차단은 중지되지 않으며 while 루프도 튀어나옵니다. 결코 실행될 수 없는 이 상황에 대한 해결책은 while 루프가 조건부로 빠져나와야 한다는 것입니다. 위의 코드를 보면 지속적으로 변경되는 유일한 것은 가져온 길이 len과 이미 읽은 데이터입니다. 더 이상 사용할 수 없습니다. 사용할 수 있는 유일한 것은 읽은 데이터입니다. 이러한 상황에 대해 우리는 일반적으로 종료 태그에 동의합니다. 클라이언트가 보낸 데이터에 종료 태그가 포함되어 있으면 현재 데이터가 전송되었음을 의미합니다. 그러면 개선된 코드는 다음과 같습니다.

Java 코드

public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
 Socket socket = server.accept(); 
 //跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。 
 Reader reader = new InputStreamReader(socket.getInputStream()); 
 char chars[] = new char[64]; 
 int len; 
 StringBuilder sb = new StringBuilder(); 
 while ((len=reader.read(chars)) != -1) { 
  sb.append(new String(chars, 0, len)); 
 } 
 System.out.println("from client: " + sb); 
 //读完后写一句 
 Writer writer = new OutputStreamWriter(socket.getOutputStream()); 
 writer.write("Hello Client."); 
 writer.flush(); 
 writer.close(); 
 reader.close(); 
 socket.close(); 
 server.close(); 
 } 
 }

위 코드에서 서버는 클라이언트가 보낸 종료 태그, 즉 "eof"를 읽으면 데이터 수신을 종료하고 루프를 실행하면 후속 코드가 계속될 수 있습니다.

클라이언트 코드

Java 코드

public class Client { 
 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream()); 
 writer.write("Hello Server."); 
 writer.flush(); 
 //写完以后进行读操作 
 Reader reader = new InputStreamReader(client.getInputStream()); 
 char chars[] = new char[64]; 
 int len; 
 StringBuffer sb = new StringBuffer(); 
 while ((len=reader.read(chars)) != -1) { 
  sb.append(new String(chars, 0, len)); 
 } 
 System.out.println("from server: " + sb); 
 writer.close(); 
 reader.close(); 
 client.close(); 
 } 
 }

在上述代码中我们先是给服务端发送了一段数据，之后读取服务端返回来的数据，跟之前的服务端一样在读的过程中有可能导致程序一直挂在那里，永远跳不出while循环。这段代码配合服务端的第一段代码就正好让我们分析服务端永远在那里接收数据，永远跳不出while循环，也就没有之后的服务端返回数据给客户端，客户端也就不可能接收到服务端返回的数据。解决方法如服务端第二段代码所示，在客户端发送数据完毕后，往输出流里面写入结束标记告诉服务端数据已经发送完毕了，同样服务端返回数据完毕后也发一个标记告诉客户端。那么修改后的客户端代码就应该是这个样子：

Java代码    

public class Client { 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream()); 
 writer.write("Hello Server."); 
 writer.write("eof"); 
 writer.flush(); 
 //写完以后进行读操作 
 Reader reader = new InputStreamReader(client.getInputStream()); 
 char chars[] = new char[64]; 
 int len; 
 StringBuffer sb = new StringBuffer(); 
 String temp; 
 int index; 
 while ((len=reader.read(chars)) != -1) { 
  temp = new String(chars, 0, len); 
  if ((index = temp.indexOf("eof")) != -1) { 
  sb.append(temp.substring(0, index)); 
  break; 
  } 
  sb.append(new String(chars, 0, len)); 
 } 
 System.out.println("from server: " + sb); 
 writer.close(); 
 reader.close(); 
 client.close(); 
 } 
 }

我们日常使用的比较多的都是这种客户端发送数据给服务端，服务端接收数据后再返回相应的结果给客户端这种形式。只是客户端和服务端之间不再是这种一对一的关系，而是下面要讲到的多个客户端对应同一个服务端的情况。      

      3、多个客户端连接同一个服务端

       像前面讲的两个例子都是服务端接收一个客户端的请求之后就结束了，不能再接收其他客户端的请求了，这往往是不能满足我们的要求的。通常我们会这样做：

Java代码       

public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 while (true) { 
  //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
 Socket socket = server.accept(); 
  //跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。 
 Reader reader = new InputStreamReader(socket.getInputStream()); 
  char chars[] = new char[64]; 
  int len; 
  StringBuilder sb = new StringBuilder(); 
  String temp; 
  int index; 
  while ((len=reader.read(chars)) != -1) { 
  temp = new String(chars, 0, len); 
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收 
   sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
  System.out.println("from client: " + sb); 
  //读完后写一句 
 Writer writer = new OutputStreamWriter(socket.getOutputStream()); 
  writer.write("Hello Client."); 
  writer.flush(); 
  writer.close(); 
  reader.close(); 
  socket.close(); 
 } 
 } 
 }

在上面代码中我们用了一个死循环，在循环体里面ServerSocket调用其accept方法试图接收来自客户端的连接请求。当没有接收到请求的时候，程序会在这里阻塞直到接收到来自客户端的连接请求，之后会跟当前建立好连接的客户端进行通信，完了后会接着执行循环体再次尝试接收新的连接请求。这样我们的ServerSocket就能接收来自所有客户端的连接请求了，并且与它们进行通信了。这就实现了一个简单的一个服务端与多个客户端进行通信的模式。

       上述例子中虽然实现了一个服务端跟多个客户端进行通信，但是还存在一个问题。在上述例子中，我们的服务端处理客户端的连接请求是同步进行的，每次接收到来自客户端的连接请求后，都要先跟当前的客户端通信完之后才能再处理下一个连接请求。这在并发比较多的情况下会严重影响程序的性能，为此，我们可以把它改为如下这种异步处理与客户端通信的方式：

Java代码        

public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 while (true) { 
  //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
  Socket socket = server.accept(); 
  //每接收到一个Socket就建立一个新的线程来处理它 
  new Thread(new Task(socket)).start(); 
 } 
 } 
 /** 
 * 用来处理Socket请求的 
 */ 
 static class Task implements Runnable { 
 private Socket socket; 
 public Task(Socket socket) { 
  this.socket = socket; 
 } 
 public void run() { 
  try { 
  handleSocket(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 /** 
 * 跟客户端Socket进行通信 
 * @throws Exception 
 */ 
 private void handleSocket() throws Exception { 
  Reader reader = new InputStreamReader(socket.getInputStream()); 
  char chars[] = new char[64]; 
  int len; 
  StringBuilder sb = new StringBuilder(); 
  String temp; 
  int index; 
  while ((len=reader.read(chars)) != -1) { 
  temp = new String(chars, 0, len); 
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收 
  sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
  System.out.println("from client: " + sb); 
  //读完后写一句 
 Writer writer = new OutputStreamWriter(socket.getOutputStream()); 
  writer.write("Hello Client."); 
  writer.flush(); 
  writer.close(); 
  reader.close(); 
  socket.close(); 
 } 
 } 
 }

在上面代码中，每次ServerSocket接收到一个新的Socket连接请求后都会新起一个线程来跟当前Socket进行通信，这样就达到了异步处理与客户端Socket进行通信的情况。

       在从Socket的InputStream中接收数据时，像上面那样一点点的读就太复杂了，有时候我们就会换成使用BufferedReader来一次读一行，如：

Java代码        

 public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 while (true) { 
  //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
  Socket socket = server.accept(); 
  //每接收到一个Socket就建立一个新的线程来处理它 
  new Thread(new Task(socket)).start(); 
 } 
 } 
 /** 
 * 用来处理Socket请求的 
 */ 
 static class Task implements Runnable { 
 private Socket socket; 
 public Task(Socket socket) { 
  this.socket = socket; 
 } 
 public void run() { 
  try { 
  handleSocket(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 /** 
 * 跟客户端Socket进行通信 
 * @throws Exception 
 */ 
 private void handleSocket() throws Exception { 
  BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
  StringBuilder sb = new StringBuilder(); 
  String temp; 
  int index; 
  while ((temp=br.readLine()) != null) { 
  System.out.println(temp); 
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收 
  sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
  System.out.println("from client: " + sb); 
  //读完后写一句 
 Writer writer = new OutputStreamWriter(socket.getOutputStream()); 
  writer.write("Hello Client."); 
  writer.write("eof\n"); 
  writer.flush(); 
  writer.close(); 
  br.close(); 
  socket.close(); 
 } 
 } 
 }

这个时候需要注意的是，BufferedReader的readLine方法是一次读一行的，这个方法是阻塞的，直到它读到了一行数据为止程序才会继续往下执行，那么readLine什么时候才会读到一行呢？直到程序遇到了换行符或者是对应流的结束符readLine方法才会认为读到了一行，才会结束其阻塞，让程序继续往下执行。所以我们在使用BufferedReader的readLine读取数据的时候一定要记得在对应的输出流里面一定要写入换行符（流结束之后会自动标记为结束，readLine可以识别），写入换行符之后一定记得如果输出流不是马上关闭的情况下记得flush一下，这样数据才会真正的从缓冲区里面写入。对应上面的代码我们的客户端程序应该这样写：

Java代码

 public class Client { 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream()); 
 writer.write("Hello Server."); 
 writer.write("eof\n"); 
 writer.flush(); 
 //写完以后进行读操作 
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream())); 
 StringBuffer sb = new StringBuffer(); 
 String temp; 
 int index; 
 while ((temp=br.readLine()) != null) { 
  if ((index = temp.indexOf("eof")) != -1) { 
  sb.append(temp.substring(0, index)); 
  break; 
  } 
  sb.append(temp); 
 } 
 System.out.println("from server: " + sb); 
 writer.close(); 
 br.close(); 
 client.close(); 
 } 
 }

      4、设置超时时间

       假设有这样一种需求，我们的客户端需要通过Socket从服务端获取到XX信息，然后给用户展示在页面上。我们知道Socket在读数据的时候是阻塞式的，如果没有读到数据程序会一直阻塞在那里。在同步请求的时候我们肯定是不能允许这样的情况发生的，这就需要我们在请求达到一定的时间后控制阻塞的中断，让程序得以继续运行。Socket为我们提供了一个setSoTimeout()方法来设置接收数据的超时时间，单位是毫秒。当设置的超时时间大于0，并且超过了这一时间Socket还没有接收到返回的数据的话，Socket就会抛出一个SocketTimeoutException。

       假设我们需要控制我们的客户端在开始读取数据10秒后还没有读到数据就中断阻塞的话我们可以这样做： 

Java代码  

public class Client { 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream()); 
 writer.write("Hello Server."); 
 writer.write("eof\n"); 
 writer.flush(); 
 //写完以后进行读操作 
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream())); 
 //设置超时间为10秒 
 client.setSoTimeout(10*1000); 
 StringBuffer sb = new StringBuffer(); 
 String temp; 
 int index; 
 try { 
  while ((temp=br.readLine()) != null) { 
  if ((index = temp.indexOf("eof")) != -1) { 
   sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
 } catch (SocketTimeoutException e) { 
  System.out.println("数据读取超时。"); 
 } 
 System.out.println("from server: " + sb); 
 writer.close(); 
 br.close(); 
 client.close(); 
 } 
 }

       5、接收数据乱码

       对于这种服务端或客户端接收中文乱码的情况通常是因为数据发送时使用的编码跟接收时候使用的编码不一致。比如有下面这样一段服务端代码：

Java代码 

 public class Server { 
 public static void main(String args[]) throws IOException { 
 //为了简单起见，所有的异常信息都往外抛 
 int port = 8899; 
 //定义一个ServerSocket监听在端口8899上 
 ServerSocket server = new ServerSocket(port); 
 while (true) { 
  //server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的 
  Socket socket = server.accept(); 
  //每接收到一个Socket就建立一个新的线程来处理它 
  new Thread(new Task(socket)).start(); 
 } 
 } 
 /** 
 * 用来处理Socket请求的 
 */ 
 static class Task implements Runnable { 
 private Socket socket; 
 public Task(Socket socket) { 
  this.socket = socket; 
 } 
 public void run() { 
  try { 
  handleSocket(); 
  } catch (Exception e) { 
  e.printStackTrace(); 
  } 
 } 
 /** 
 * 跟客户端Socket进行通信 
 * @throws Exception 
 */ 
 private void handleSocket() throws Exception { 
  BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK")); 
  StringBuilder sb = new StringBuilder(); 
  String temp; 
  int index; 
  while ((temp=br.readLine()) != null) { 
  System.out.println(temp); 
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收 
  sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
  System.out.println("客户端: " + sb); 
  //读完后写一句 
 Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8"); 
  writer.write("你好，客户端。"); 
  writer.write("eof\n"); 
  writer.flush(); 
  writer.close(); 
  br.close(); 
  socket.close(); 
 } 
 } 
 }

这里用来测试我就弄的混乱了一点。在上面服务端代码中我们在定义输入流的时候明确定义了使用GBK编码来读取数据，而在定义输出流的时候明确指定了将使用UTF-8编码来发送数据。如果客户端上送数据的时候不以GBK编码来发送的话服务端接收的数据就很有可能会乱码；同样如果客户端接收数据的时候不以服务端发送数据的编码，即UTF-8编码来接收数据的话也极有可能会出现数据乱码的情况。所以，对于上述服务端代码，为使我们的程序能够读取对方发送过来的数据，而不出现乱码情况，我们的客户端应该是这样的：

Java代码

public class Client { 
 public static void main(String args[]) throws Exception { 
 //为了简单起见，所有的异常都直接往外抛 
 String host = "127.0.0.1"; //要连接的服务端IP地址 
 int port = 8899; //要连接的服务端对应的监听端口 
 //与服务端建立连接 
 Socket client = new Socket(host, port); 
 //建立连接后就可以往服务端写数据了 
 Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK"); 
 writer.write("你好，服务端。"); 
 writer.write("eof\n"); 
 writer.flush(); 
 //写完以后进行读操作 
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8")); 
 //设置超时间为10秒 
 client.setSoTimeout(10*1000); 
 StringBuffer sb = new StringBuffer(); 
 String temp; 
 int index; 
 try { 
  while ((temp=br.readLine()) != null) { 
  if ((index = temp.indexOf("eof")) != -1) { 
   sb.append(temp.substring(0, index)); 
   break; 
  } 
  sb.append(temp); 
  } 
 } catch (SocketTimeoutException e) { 
  System.out.println("数据读取超时。"); 
 } 
 System.out.println("服务端: " + sb); 
 writer.close(); 
 br.close(); 
 client.close(); 
 } 
 }

위 내용은 Java의 소켓 프로그래밍 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!