1.简单socket完成消息发送与接收

服务端:

  1. package com.wfd360.com.socket;
  2.  
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6.  
  7. /**
  8.  * @Copyright (C)
  9.  * @Author: LI DONG PING
  10.  * @Date: 2019-09-01 15:14
  11.  * @Description:
  12.  */
  13. public class ServerSocketDemo {
  14.     /**
  15.      * ServerSocket 的构造方法如下所示。
  16.      * ServerSocket()：无参构造方法。
  17.      * ServerSocket(int port)：创建绑定到特定端口的服务器套接字。
  18.      * ServerSocket(int port,int backlog)：使用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口。
  19.      * ServerSocket(int port,int backlog,InetAddress bindAddr)：使用指定的端口、监听 backlog 和要绑定到本地的 IP 地址创建服务器。
  20.      * <p>
  21.      * ===================================================================================================================
  22.      * ServerSocket 的常用方法如下所示。
  23.      * Server accept()：监听并接收到此套接字的连接。
  24.      * void bind(SocketAddress endpoint)：将 ServerSocket 绑定到指定地址（IP 地址和端口号）。
  25.      * void close()：关闭此套接字。
  26.      * InetAddress getInetAddress()：返回此服务器套接字的本地地址。
  27.      * int getLocalPort()：返回此套接字监听的端口。
  28.      * SocketAddress getLocalSoclcetAddress()：返回此套接字绑定的端口的地址，如果尚未绑定则返回 null。
  29.      * int getReceiveBufferSize()：获取此 ServerSocket 的 SO_RCVBUF 选项的值，该值是从 ServerSocket 接收的套接字的建议缓冲区大小。
  30.      *
  31.      * @param args 服务端设计步骤:
  32.      *             1.创建socket服务端
  33.      *             2.监听客户端
  34.      *             3.获取输入流
  35.      *             4.输出
  36.      */
  37.     public static void main(String[] args) {
  38.         ServerSocket serverSocket = null;
  39.         Socket server = null;
  40.         BufferedReader reader = null;
  41.         BufferedWriter writer = null;
  42.         try {
  43.             //1.建立socket服务器
  44.             serverSocket = new ServerSocket(1001);
  45.             System.out.println("服务端创建成功----");
  46.             while (true) {
  47.                 //2.监听客户端连接
  48.                 server = serverSocket.accept();
  49.                 //3.读取客户端数据
  50.                 reader = new BufferedReader(new InputStreamReader(server.getInputStream()));
  51.                 String s = reader.readLine();
  52.                 System.out.println("服务端收到数据:" + s);
  53.                 //4.响应客户端
  54.                 writer = new BufferedWriter(new OutputStreamWriter(server.getOutputStream()));
  55.                 writer.write("已经收到数据[" + s + "]\n");
  56.                 //清除缓存
  57.                 writer.flush();
  58.             }
  59.  
  60.         } catch (IOException e) {
  61.             e.printStackTrace();
  62.         } finally {
  63.             try {
  64.                 //关闭资源
  65.                 if (writer != null) {
  66.                     writer.close();
  67.                 }
  68.                 if (reader != null) {
  69.                     reader.close();
  70.                 }
  71.                 if (server != null) {
  72.                     server.close();
  73.                 }
  74.                 if (serverSocket != null) {
  75.                     serverSocket.close();
  76.                 }
  77.             } catch (Exception e) {
  78.                 e.printStackTrace();
  79.             }
  80.         }
  81.     }
  82.  
  83. }

客户端:

  1. package com.wfd360.com.socket;
  2.  
  3. import java.io.*;
  4. import java.net.Socket;
  5.  
  6. /**
  7.  * @Copyright
  8.  * @Author: LI DONG PING
  9.  * @Date: 2019-09-01 15:50
  10.  * @Description:
  11.  */
  12. public class ClientSocketDemo {
  13.     /**
  14.      * 客户端设计逻辑:
  15.      * 1.创建socket通信,设置IP和端口
  16.      * 2.建立IO输出流,向服务端发送数据
  17.      * 3.建立IO输入流,读取服务端应答的数据
  18.      *
  19.      * @param args
  20.      */
  21.     public static void main(String[] args) {
  22.         Socket socket = null;
  23.         BufferedWriter writer = null;
  24.         BufferedReader reader = null;
  25.  
  26.         try {
  27.             //1.创建socket通信
  28.             socket = new Socket("localhost", 1001);
  29.             //2.建立IO输出流,向服务端发送数据
  30.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  31.             //注意这里必须加\n,因为是按照行读取
  32.             writer.write("短信发送2\n");
  33.             writer.flush();
  34.             //3.建立IO输入流,读取服务端应答的数据
  35.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  36.             String s = reader.readLine();
  37.             System.out.println("客户端收到数据:" + s);
  38.  
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             try {
  43.                 if (reader != null) {
  44.                     reader.close();
  45.                 }
  46.                 if (writer != null) {
  47.                     writer.close();
  48.                 }
  49.                 if (socket != null) {
  50.                     socket.close();
  51.                 }
  52.             } catch (Exception e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  56.     }
  57. }

2.socket中的常用io操作

　　常用类:https://www.cnblogs.com/newAndHui/p/11514269.html

　　案例:

  1. package com.wfd360.com.io;
  2.  
  3. import org.junit.Test;
  4.  
  5. import java.io.*;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8.  
  9. /**
  10.  * @Copyright (C)
  11.  * @Author: LI DONG PING
  12.  * @Date: 2019-09-12 11:15
  13.  * @Description:
  14.  */
  15. public class FileDemo {
  16.     /**
  17.      * 需求:
  18.      * 将a.txt 复制到 b.txt
  19.      *
  20.      * @param args
  21.      */
  22.     public static void main(String[] args) throws Exception {
  23.     }
  24.  
  25.     @Test
  26.     public void test2() throws Exception {
  27.        // String filePath="E:\\test\\day18_数据结构.docx";
  28.         String filePath="E:\\test\\a.txt";
  29.         String filePathNew="E:\\test\\b.txt";
  30.         //1.读取本地文件a
  31.         File file = new File(filePath);
  32.         DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file));
  33.         //读取文件名
  34.        // String fileName = dataInputStream.readUTF();
  35.         //读取文件大小
  36.        // long fileSize = dataInputStream.readLong();
  37.        // System.out.println("fileName="+fileName+",fileSize="+fileSize);
  38.         //准备写入文件对象
  39.         File fileNew = new File(filePathNew);
  40.        // fileNew.createNewFile();
  41.         DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(fileNew));
  42.  
  43.         //按照字节读取文件
  44.         byte[] aByte = new byte[128];
  45.         System.out.println("length="+aByte.length);
  46.         int read = dataInputStream.read(aByte, 0, aByte.length);
  47.         while (read!=-1){
  48.             //当前文件内容
  49.             String s = new String(aByte,"gbk");
  50.             System.out.println("read="+read+"s="+s);
  51.             //写入文件
  52.             dataOutputStream.write(aByte,0,read);
  53.             dataOutputStream.flush();
  54.             read = dataInputStream.read(aByte, 0, aByte.length);
  55.         }
  56.  
  57.         //2.写入到本地文件b
  58.     }
  59.  
  60.     /**
  61.      * 需求:
  62.      * 将a.txt 复制到 b.txt
  63.      * 使用：FileInputStream，FileOutputStream
  64.      *
  65.      * @throws Exception
  66.      */
  67.     @Test
  68.     public void test1() throws Exception {
  69.         //1:读取a.txt中的内容
  70.         //1.1.建立文件
  71.         File file = new File("D:\\test\\a.txt");
  72.         //1.2.读取文件内容 字节流
  73.         FileInputStream fileInputStream = new FileInputStream(file);
  74.         //1.3.转变为处理流 gb2312
  75.         BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream, "gbk"));
  76.         //1.4.按照行读取数据
  77.         List<String> content = new ArrayList<String>();
  78.         String line = reader.readLine();
  79.         while (line != null) {
  80.             System.out.println("line=" + line);
  81.             content.add(line);
  82.             //读取下一行
  83.             line = reader.readLine();
  84.         }
  85.  
  86.         //2:写入到b.txt中
  87.         //2.1.创建文件
  88.         File fileB = new File("D:\\test\\b.txt");
  89.         boolean newFile = fileB.createNewFile();
  90.         System.out.println("newFile=" + newFile);
  91.         //2.2.创建写入文件字节流
  92.         FileOutputStream fileOutputStream = new FileOutputStream(fileB);
  93.         //2.3.转变为处理流
  94.         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(fileOutputStream, "gbk"));
  95.         for (String s : content) {
  96.             writer.write(s);
  97.         }
  98.         writer.flush();
  99.         writer.close();
  100.     }
  101. }

3.socket中java对象传送

　　java对象

  1. package com.wfd360.com.socketJava.model;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * @Copyright (C)
  7.  * @Author: LI DONG PING
  8.  * @Date: 2019-09-12 17:48
  9.  * @Description:
  10.  */
  11. public class User implements Serializable {
  12.     private String name;
  13.     private Integer age;
  14.  
  15.     public User() {
  16.     }
  17.  
  18.     public User(String name, Integer age) {
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  22.  
  23.     public String getName() {
  24.         return name;
  25.     }
  26.  
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30.  
  31.     public Integer getAge() {
  32.         return age;
  33.     }
  34.  
  35.     public void setAge(Integer age) {
  36.         this.age = age;
  37.     }
  38.  
  39.     @Override
  40.     public String toString() {
  41.         return "User{" +
  42.                 "name='" + name + '\'' +
  43.                 ", age=" + age +
  44.                 '}';
  45.     }
  46. }

　　服务端:

  1. package com.wfd360.com.socketJava;
  2.  
  3. import com.wfd360.com.socketJava.model.User;
  4.  
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9.  
  10. /**
  11.  * @Copyright (C)
  12.  * @Author: LI DONG PING
  13.  * @Date: 2019-09-01 15:14
  14.  * @Description:
  15.  */
  16. public class ServerSocketDemo {
  17.     /**
  18.      * @param args 服务端设计步骤:
  19.      *             1.创建socket服务端
  20.      *             2.监听客户端
  21.      *             3.获取输入流
  22.      *             4.输出
  23.      */
  24.     public static void main(String[] args) {
  25.         ServerSocket serverSocket = null;
  26.         Socket server = null;
  27.         ObjectInputStream objectInputStream = null;
  28.         ObjectOutputStream objectOutputStream = null;
  29.         try {
  30.             //1.建立socket服务器
  31.             serverSocket = new ServerSocket(1002);
  32.             System.out.println("服务端创建成功----");
  33.             while (true) {
  34.                 //2.监听客户端连接
  35.                 server = serverSocket.accept();
  36.                 //3.读取客户端数据
  37.                 objectInputStream = new ObjectInputStream(server.getInputStream());
  38.                 User user = (User) objectInputStream.readObject();
  39.                 System.out.println("服务端收到数据:" + user);
  40.                 //4.响应客户端
  41.                 objectOutputStream = new ObjectOutputStream(server.getOutputStream());
  42.                 user.setName("我来做服务端");
  43.                 objectOutputStream.writeObject(user);
  44.                 //清除缓存
  45.                 objectOutputStream.flush();
  46.             }
  47.  
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         } finally {
  51.             try {
  52.                 //关闭资源
  53.                 if (objectOutputStream != null) {
  54.                     objectOutputStream.close();
  55.                 }
  56.                 if (objectInputStream != null) {
  57.                     objectInputStream.close();
  58.                 }
  59.                 if (server != null) {
  60.                     server.close();
  61.                 }
  62.                 if (serverSocket != null) {
  63.                     serverSocket.close();
  64.                 }
  65.             } catch (Exception e) {
  66.                 e.printStackTrace();
  67.             }
  68.         }
  69.     }
  70.  
  71. }

　　客户端:

  1. package com.wfd360.com.socketJava;
  2.  
  3. import com.wfd360.com.socketJava.model.User;
  4.  
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.net.Socket;
  8.  
  9. /**
  10.  * @Copyright (C)
  11.  * @Author: LI DONG PING
  12.  * @Date: 2019-09-01 15:50
  13.  * @Description:
  14.  */
  15. public class ClientSocketDemo {
  16.     /**
  17.      * 客户端设计逻辑:
  18.      * 1.创建socket通信,设置IP和端口
  19.      * 2.建立IO输出流,向服务端发送数据
  20.      * 3.建立IO输入流,读取服务端应答的数据
  21.      *
  22.      * @param args
  23.      */
  24.     public static void main(String[] args) {
  25.         Socket socket = null;
  26.         ObjectOutputStream writer = null;
  27.         ObjectInputStream reader = null;
  28.  
  29.         try {
  30.             //1.创建socket通信
  31.             socket = new Socket("localhost", 1002);
  32.             //2.建立IO输出流,向服务端发送数据
  33.             writer = new ObjectOutputStream(socket.getOutputStream());
  34.             writer.writeObject(new User("无忌", 19));
  35.             writer.flush();
  36.             //3.建立IO输入流,读取服务端应答的数据
  37.             reader = new ObjectInputStream(socket.getInputStream());
  38.             User o = (User) reader.readObject();
  39.             System.out.println("==>" + o);
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         } finally {
  43.             try {
  44.                 if (reader != null) {
  45.                     reader.close();
  46.                 }
  47.                 if (writer != null) {
  48.                     writer.close();
  49.                 }
  50.                 if (socket != null) {
  51.                     socket.close();
  52.                 }
  53.             } catch (Exception e) {
  54.                 e.printStackTrace();
  55.             }
  56.         }
  57.     }
  58. }

4.多线程下的socket

　　多线程处理类

  1. package com.wfd360.com.socketThread.thread;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.net.Socket;
  8.  
  9. public class HandleServerThread extends Thread {
  10.     private Socket socket;
  11.  
  12.     public HandleServerThread(){
  13.  
  14.     }
  15.     public HandleServerThread(Socket socket){
  16.       this.socket=socket;
  17.     }
  18.  
  19.     @Override
  20.     public void run() {
  21.         try {
  22.             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  23.             String s = reader.readLine();
  24.             System.out.println("收到连接的客户端：ip="+socket.getInetAddress()+"  port:"+socket.getPort()+"  s="+s);
  25.             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  26.             writer.write("服务端收到的数据为[" + s + "]\n");
  27.             writer.flush();
  28.             writer.close();
  29.             reader.close();
  30.             socket.close();
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }

　　服务端:

  1. package com.wfd360.com.socketThread;
  2.  
  3. import com.wfd360.com.socketThread.thread.HandleServerThread;
  4.  
  5. import java.io.IOException;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8.  
  9. /**
  10.  * @Copyright (C)
  11.  * @Author: LI DONG PING
  12.  * @Date: 2019-09-01 15:14
  13.  * @Description:
  14.  */
  15. public class ServerSocketDemo {
  16.     static int port = 1103;
  17.  
  18.     /**
  19.      * 服务端开启多线程
  20.      *
  21.      * @param args
  22.      */
  23.     public static void main(String[] args) throws IOException {
  24.         ServerSocket server = new ServerSocket(port);
  25.         int i=1;
  26.         System.out.println("服务端已启动----"+i);
  27.         while (true) {
  28.             System.out.println("等待客户端连接---"+i);
  29.             Socket socket = server.accept();
  30.             System.out.println("已连接---"+i);
  31.             HandleServerThread thread = new HandleServerThread(socket);
  32.             thread.start();
  33.             i++;
  34.         }
  35.     }
  36. }

　　客户端:

  1. package com.wfd360.com.socketThread;
  2.  
  3. import java.io.*;
  4. import java.net.Socket;
  5.  
  6. /**
  7.  * @Copyright (C)
  8.  * @Author: LI DONG PING
  9.  * @Date: 2019-09-01 15:50
  10.  * @Description:
  11.  */
  12. public class ClientSocketDemo {
  13.     static String host = "192.168.0.103";
  14.     static Integer port = 1103;
  15.  
  16.     /**
  17.      * 客户端设计逻辑:
  18.      * 1.创建socket通信,设置IP和端口
  19.      * 2.建立IO输出流,向服务端发送数据
  20.      * 3.建立IO输入流,读取服务端应答的数据
  21.      *
  22.      * @param args
  23.      */
  24.     public static void main(String[] args) {
  25.         Socket socket = null;
  26.         BufferedWriter writer = null;
  27.         BufferedReader reader = null;
  28.         try {
  29.  
  30.             while (true) {
  31.                 //1.创建socket通信
  32.                 socket = new Socket(host, port);
  33.                 //2.建立IO输出流,向服务端发送数据
  34.                 writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  35.                 //读取控制台输入的数据
  36.                 System.out.print("请输入要发送的数据（结束请输入exit）：");
  37.                 String sysIn = new BufferedReader(new InputStreamReader(System.in)).readLine();
  38.                 System.out.println("sysIn=" + sysIn);
  39.                 if ("exit".equals(sysIn)) {
  40.                     break;
  41.                 }
  42.                 //注意这里必须加\n,因为是按照行读取
  43.                 writer.write("向服务端发送数据：" + sysIn + "\n");
  44.                 writer.flush();
  45.                 //3.建立IO输入流,读取服务端应答的数据
  46.                 reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  47.                 String s = reader.readLine();
  48.                 System.out.println("客户端收到数据:" + s);
  49.             }
  50.  
  51.         } catch (IOException e) {
  52.             e.printStackTrace();
  53.         } finally {
  54.             try {
  55.                 if (reader != null) {
  56.                     reader.close();
  57.                 }
  58.                 if (writer != null) {
  59.                     writer.close();
  60.                 }
  61.                 if (socket != null) {
  62.                     socket.close();
  63.                 }
  64.             } catch (Exception e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.     }
  69. }

5.socket下的多线程文件传输

　　多线程处理类

  1. package com.wfd360.com.socketFile.thread;
  2.  
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.File;
  6. import java.io.FileOutputStream;
  7. import java.net.Socket;
  8.  
  9. public class HandleServerThread extends Thread {
  10.     private Socket socket;
  11.  
  12.     public HandleServerThread() {
  13.  
  14.     }
  15.  
  16.     public HandleServerThread(Socket socket) {
  17.         this.socket = socket;
  18.     }
  19.  
  20.     /**
  21.      * 将文件保存到本地
  22.      */
  23.     @Override
  24.     public void run() {
  25.         try {
  26.             //需要写入的文件
  27.             File file = new File("E:\\test\\c.txt");
  28.             file.createNewFile();
  29.  
  30.             //处理流 输入
  31.             DataInputStream dataInputStream = new DataInputStream(socket.getInputStream());
  32.             String fileName = dataInputStream.readUTF();
  33.             long fileSize = dataInputStream.readLong();
  34.             System.out.println("fileName=" + fileName + ",fileSize=" + fileSize);
  35.             //处理流 输出
  36.             DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(file));
  37.  
  38.             //采用字节数组读取文件内容
  39.             byte[] bytes = new byte[128];
  40.             int readSize = dataInputStream.read(bytes, 0, bytes.length);
  41.             System.out.println("readSize=" + readSize);
  42.             while (readSize != -1) {
  43.                 //写入本地文件
  44.                 dataOutputStream.write(bytes, 0, readSize);
  45.                 dataOutputStream.flush();
  46.                 readSize = dataInputStream.read(bytes, 0, bytes.length);
  47.                 System.out.println("readSize=" + readSize);
  48.             }
  49.             System.out.println("========文件上传完成==========");
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  54. }

　　服务端

  1. package com.wfd360.com.socketFile;
  2.  
  3. import com.wfd360.com.socketFile.thread.HandleServerThread;
  4.  
  5. import java.io.IOException;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8.  
  9. /**
  10.  * @Copyright (C) 四川千行你我科技有限公司
  11.  * @Author: LI DONG PING
  12.  * @Date: 2019-09-01 15:14
  13.  * @Description:
  14.  */
  15. public class ServerSocketDemo {
  16.     static int port = 1103;
  17.  
  18.     /**
  19.      * 服务端开启多线程
  20.      *
  21.      * @param args
  22.      */
  23.     public static void main(String[] args) throws IOException {
  24.         ServerSocket server = new ServerSocket(port);
  25.         int i=1;
  26.         System.out.println("服务端已启动----"+i);
  27.         while (true) {
  28.             System.out.println("等待客户端连接---"+i);
  29.             Socket socket = server.accept();
  30.             System.out.println("已连接---"+i);
  31.             HandleServerThread thread = new HandleServerThread(socket);
  32.             thread.start();
  33.             i++;
  34.         }
  35.     }
  36. }

　　客户端

  1. package com.wfd360.com.socketFile;
  2.  
  3. import java.io.*;
  4. import java.net.Socket;
  5.  
  6. /**
  7.  * @Copyright (C) 四川千行你我科技有限公司
  8.  * @Author: LI DONG PING
  9.  * @Date: 2019-09-01 15:50
  10.  * @Description:
  11.  */
  12. public class ClientSocketDemo {
  13.     static String host = "192.168.0.103";
  14.     static Integer port = 1103;
  15.  
  16.     /**
  17.      * 客户端设计逻辑:
  18.      * 1.创建socket通信,设置IP和端口
  19.      * 2.建立IO输出流,向服务端发送数据
  20.      * 3.建立IO输入流,读取服务端应答的数据
  21.      *
  22.      * @param args
  23.      */
  24.     public static void main(String[] args) throws Exception {
  25.         Socket socket = new Socket(host, port);
  26.         //准备上传文件
  27.         File file = new File("E:\\test\\a.txt");
  28.         DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file));
  29.         //准备输出 处理流
  30.         DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());
  31.         dataOutputStream.writeUTF(file.getName());
  32.         dataOutputStream.flush();
  33.         dataOutputStream.writeLong(file.length());
  34.         dataOutputStream.flush();
  35.         //准备以字节的形式输出
  36.         byte[] bytes = new byte[128];
  37.         int readSize = dataInputStream.read(bytes, 0, bytes.length);
  38.         while (readSize != -1) {
  39.             System.out.println("readSize=" + readSize);
  40.             dataOutputStream.write(bytes, 0, readSize);
  41.             dataOutputStream.flush();
  42.             readSize = dataInputStream.read(bytes, 0, bytes.length);
  43.         }
  44.         System.out.println("-----完成-------");
  45.         dataInputStream.close();
  46.         //当关闭的时候，服务端才会停止监听
  47.         dataOutputStream.close();
  48.     }
  49. }

6.UDP的socket

　　服务端

  1. package com.wfd360.com.socketUDP;
  2.  
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.net.SocketException;
  7.  
  8. public class UDPServer {
  9.     /**
  10.      * 一、DatagramPacket类：
  11.      *
  12.      * 如果把DatagramSocket比作创建的港口码头，那么DatagramPacket就是发送和接收数据的集装箱。
  13.      * 构造函数：一个用来接收数据，一个用来发送数据
  14.      * public DatagramPacket(byte[] buf,int length) //接收数据
  15.      * 构造 DatagramPacket 用来接收长度为 ilength 的包。
  16.      * public DatagramPacket(byte[] buf,int length,InetAddress address,int port)
  17.      * 构造数据报文包用来把长度为 ilength 的包传送到指定宿主的指定的端口号。
  18.      * getAddress()
  19.      * 返回接收或发送此数据报文的机器的 IP 地址。
  20.      * getData()
  21.      * 返回接收的数据或发送出的数据。
  22.      * getLength()
  23.      * 返回发送出的或接收到的数据的长度。
  24.      * getPort()
  25.      * 返回接收或发送该数据报文的远程主机端口号。
  26.      *
  27.      * 二、DatagramSocket类
  28.      *
  29.      * 此类表示用来发送和接收数据报包的套接字。 数据报套接字是包投递服务的发送或接收点。
  30.      * DatagramSocket(int port)     创建数据报套接字并将其绑定到本地主机上的指定端口。
  31.      * DatagramSocket(int port, InetAddress laddr)     创建数据报套接字，将其绑定到指定的本地地址。
  32.      *
  33.      * receive(DatagramPacket p)
  34.      *              从此套接字接收数据报包。
  35.      * void send(DatagramPacket p)
  36.      *              从此套接字发送数据报包。
  37.      * bind(SocketAddress addr)
  38.      *              将此 DatagramSocket 绑定到特定的地址和端口。
  39.      * void close()
  40.      *              关闭此数据报套接字。
  41.      * void connect(InetAddress address, int port)
  42.      *              将套接字连接到此套接字的远程地址。
  43.      * void connect(SocketAddress addr)
  44.      *              将此套接字连接到远程套接字地址（IP 地址 + 端口号）。
  45.      * void disconnect()
  46.      *              断开套接字的连接。
  47.      * getInetAddress()
  48.      *              返回此套接字连接的地址。
  49.      * InetAddress getLocalAddress()
  50.      *              获取套接字绑定的本地地址。
  51.      *
  52.      * 三、InetAddress类
  53.      * InetAddress用于表示计算机IP地址的一个类，而在日常应用中的IP地址用"192.168.0.1",
  54.      * "WWW.it315.org"等字符串格式表示的。
  55.      * getByName方法
  56.      * getHostAddress方法
  57.      * @param args
  58.      */
  59.     public static void main(String[] args) throws Exception {
  60.         int port=1001;
  61.         String host="192.168.0.103";
  62.  
  63.         //1.创建服务端 DatagramSocket(int port, InetAddress laddr)     创建数据报套接字，将其绑定到指定的本地地址。
  64.         DatagramSocket datagramSocket = new DatagramSocket(port);
  65.         System.out.println("服务已开启-----");
  66.         //2.接收数据
  67.         byte[] bytes=new byte[128];
  68.         DatagramPacket datagramPacket =new DatagramPacket(bytes,0,bytes.length) ;
  69.         System.out.println("-----等待接收数据");
  70.         datagramSocket.receive(datagramPacket);
  71.         InetAddress address = datagramPacket.getAddress();
  72.         int port1 = datagramPacket.getPort();
  73.         int length = datagramPacket.getLength();
  74.         byte[] data = datagramPacket.getData();
  75.         String s = new String(data);
  76.         String format = String.format("address=%s,port=%s,length=%s,data=%s", address, port1, length, s);
  77.         System.out.println(format);
  78.         //3.发送数据包
  79.         String sendData="发送数据-"+s;
  80.         byte[] bytes1 = sendData.getBytes();
  81.         InetAddress byName = InetAddress.getByName(host);
  82.         DatagramPacket datagramPacketSend =new DatagramPacket(bytes1,0,bytes1.length,byName,1002) ;
  83.         datagramSocket.send(datagramPacketSend);
  84.     }
  85. }

　　客户端

  1. package com.wfd360.com.socketUDP;
  2.  
  3. import java.net.DatagramPacket;
  4. import java.net.DatagramSocket;
  5. import java.net.InetAddress;
  6. import java.net.SocketException;
  7.  
  8. public class UDPClient {
  9.     public static void main(String[] args) throws Exception {
  10.         int port=1002;
  11.         String host="192.168.0.103";
  12.  
  13.         //1.创建服务端 DatagramSocket(int port, InetAddress laddr)     创建数据报套接字，将其绑定到指定的本地地址。
  14.         DatagramSocket datagramSocket = new DatagramSocket(port);
  15.  
  16.         //3.发送数据包
  17.         String sendData="你好吗?";
  18.         byte[] bytes1 = sendData.getBytes();
  19.         InetAddress byName = InetAddress.getByName(host);
  20.         DatagramPacket datagramPacketSend =new DatagramPacket(bytes1,0,bytes1.length,byName,1001) ;
  21.         datagramSocket.send(datagramPacketSend);
  22.         //2.接收数据
  23.         byte[] bytes=new byte[128];
  24.         DatagramPacket datagramPacket =new DatagramPacket(bytes,0,bytes.length) ;
  25.         System.out.println("-----等待接收数据");
  26.         datagramSocket.receive(datagramPacket);
  27.         InetAddress address = datagramPacket.getAddress();
  28.         int port1 = datagramPacket.getPort();
  29.         int length = datagramPacket.getLength();
  30.         byte[] data = datagramPacket.getData();
  31.         String s = new String(data);
  32.         String format = String.format("address=%s,port=%s,length=%s,data=%s", address, port1, length, s);
  33.         System.out.println(format);
  34.  
  35.     }
  36. }

　　完美!

socket系统化入门的更多相关文章

  1. socket.io入门整理教程

    socket.io入门整理  发布于 5 年前  作者 dtrex  124983 次浏览  最后一次编辑是 1 年前 我自己在用socket.io开发,对官方网站上的文档,进行简单的整理,然后自己写 ...

  2. 最基础的Python的socket编程入门教程

    最基础的Python的socket编程入门教程 本文介绍使用Python进行Socket网络编程,假设读者已经具备了基本的网络编程知识和Python的基本语法知识,本文中的代码如果没有说明则都是运行在 ...

  3. Socket.io 入门 - Renyi的博客

    Socket.io Vue 中使用 NPM 安装 npm install vue-socket.io --save npm install --save socket.io-client 引用 详情 ...

  4. Java Socket NIO入门

    Java Socket.SocketServer的读写.连接事件监听,都是阻塞式的.Java提供了另外一种非阻塞式读写.连接事件监听方式——NIO.本文简单的介绍一个NIO Socket入门例子,原理 ...

  5. Node.js、Express、Socket.io 入门

    前言 周末断断续续的写了第一个socket.io Demo.初次接触socket.io是从其官网看到的,看着get started做了一遍,根据官网的Demo能提供简单的服务端和客户端通讯. 这个De ...

  6. socket通信入门

    以一个基本的python程序为例解释 源代码如下: #!/usr/bin/env python  #指出代码用什么程序去运行它.首先会到env设置里查找python的安装路径,再调用对应路径下的解释器 ...

  7. socket.io 入门教程

    转载自:http://deadhorse.me/nodejs/2011/12/29/socket.io_induction.html socket.io socket.io是一个以实现跨浏览器.跨平台 ...

  8. 转载：socket.io 入门

    原文链接:http://cnodejs.org/topic/50a1fcc7637ffa4155b5a264 我自己在用socket.io开发,对官方网站上的文档,进行简单的整理,然后自己写了一个简单 ...

  9. Java Socket(1): 入门

    前言:在最近一个即将结束的项目中使用到了Socket编程,用于调用另一系统进行处理并返回数据.故把Socket的基础知识总结梳理一遍. 一.TCP/IP协议 既然是网络编程,涉及几个系统之间的交互,那 ...

随机推荐

  1. RabbitMQ消息确认机制

    文章目录 1. 事务机制2. Confirm模式2.1 生产者2.1.1 普通Confirm模式2.1.2 批量Confirm模式2.1.3 异步Confirm模式2.2 消费者3. 其他 消费者如何 ...

  2. 协程,yield,i多路复用,复习

    课程回顾: 线程池 队列:同一进程内的队列 先进先出 后进先出 优先级队列 线程池中的回调函数是谁在调用? 线程池中的回调函数是子线程调用的,和父线程没有关系 进程池中的会点函数是父进程调用的,和子进 ...

  3. wireshark-wincap安装问题

    winpcap关键模块 32位系统: C:\Windows\system32\wpcap.dll C:\Windows\system32\Packet.dll C:\Windows\system32\ ...

  4. ESA2GJK1DH1K开发教程: 来看看最新整理的整个开发板的教程大纲吧

    项目开发:教程大纲(测试板型号:ESA2GJK1DH1K) 购买链接: https://item.taobao.com/item.htm?spm=a2oq0.12575281.0.0.25911deb ...

  5. Android Studio 星云常用配置工具箱

    1. 安装插件 1.1 Android View绑定框架 开源地址:https://github.com/JakeWharton/butterknife 插件地址: https://github.co ...

  6. 【border树】【P2375】动物园

    Description 给定一个字符串 \(S\),对每个前缀求长度不超过该前缀一半的公共前后缀个数. 共有 \(T\) 组数据,每组数据的输出是 \(O(1)\) 的. Limitations \( ...

  7. 解析node-cors模块

    (function () { 'use strict'; var assign = require('object-assign'); var vary = require('vary'); var ...

  8. ping-pong buffer

    1 什么是pingpong? pingpong是一种数据缓存的手段,通过pingpong操作可以提高数据传输的效率. 2 什么时候需要pingpong? 在两个模块间交换数据时,上一级处理的结果不能马 ...

  9. Visual Studio报错/plugin.vs.js，行：1074，错误：缺少标识符、字符串或数字

    C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\Common7\IDE\PrivateAssemblies/plugin. ...

  10. window 运行spark报错

    Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties // :: ERROR Shell: F ...