java网络编程（套接字）

套接字是java提供一套进行网络通信的API---TCP/UDP；

ISO七层模型

　　物理层 、数据链路层 、传输层-IP、 网络层-UDP/TCP 、会话层 、 表示层、 应用层 ---HTTP FTP POP3 SMTP...

IP地址：在网络中标识计算机地址的---IPv4---用四组整数(0-255)标识一个IP地址---123.125.43.11---IPv6

端口号: 用于指定接收或者发送消息的端口---0-65535---0-1024被计算机内部占用

UDP

　　基于流的，不需要建立连接，不可靠，会对数据进行封包，每个包是64k大小，传输效率是比较高。例如直播

　　java提供了一套套接字用于UDP通信：

　　　　1.InetSocketAddress("IP地址",端口号)：表示IP地址和端口号；

　　　　2.DatgramSocket（）：用来发送和接收数据包的套接字；

　　　　3.DatagramPacket（byte[] buf, int length, SocketAddress address）：用来对数据封包，以便传输；

　　发送端基本步骤：

　　　　1.创建发送数据套接字对象；

　　　　2.创建目的地的IP地址和发送端口；

　　　　3.将数据封包；

　　　　4.发送（send（DatagramPacket  dp）方法）；

　　　　5.关闭套接字（close（））；

　　接收端基本步骤：

　　　　1.创建接收数据的套接字对象并绑定接收数据的端口；

　　　　2.创建数据封包用来储存数据；

　　　　3.接收数据（receive（DatagramPacket  dp））；

　　　　4.关闭套接字（close（））；

 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetSocketAddress;
 import java.util.Scanner;
 
 public class UDPChatDemo {
 
     public static void main(String[] args) {
 
         new Thread(new Sender()).start();
         new Thread(new Receiver()).start();
     }
 
 }
 
 // 发送端
 class Sender implements Runnable {
 
     @SuppressWarnings("resource")
     @Override
     public void run() {
 
         try {
             // 准备套接字对象
             DatagramSocket ds = new DatagramSocket();
 
             // 创建一个地址对象
             InetSocketAddress isa = new InetSocketAddress("localhost", 9527);
 
             // 从控制台来获取数据
             Scanner s = new Scanner(System.in);
 
             while (true) {
                 String msg = s.nextLine();
 
                 // 将数据封包
                 DatagramPacket dp = new DatagramPacket(msg.getBytes(), msg.getBytes().length, isa);
 
                 // 发送数据
                 ds.send(dp);
 
                 // 判断这个语句是否是exit
                 if (msg == "exit" || msg != null && msg.equals("exit")) {
                     break;
                 }
             }
 
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
 }
 
 class Receiver implements Runnable {
 
     @SuppressWarnings("resource")
     @Override
     public void run() {
 
         try {
             // 准备套接字对象，绑定端口号
             DatagramSocket ds = new DatagramSocket(9527);
 
             // 准备数据包
             DatagramPacket dp = new DatagramPacket(new byte[1024], 1024);
 
             while (true) {
 
                 // 接收数据
                 ds.receive(dp);
 
                 // 获取数据
                 String msg = new String(dp.getData(), 0, dp.getLength());
                 if (msg == "exit" || msg != null && msg.equals("exit")) {
                     break;
                 }
 
                 // 获取地址
                 System.out.print(dp.getAddress() + ":");
                 System.out.println(msg);
             }
 
         } catch (Exception e) {
             e.printStackTrace();
         }
 
     }
 
 }

TCP

　　基于流的，需要建立连接，经过了三次握手，理论上不限制数据的大小，传输速率比较低。例如文件的传输

　　java提供的套接字：

　　　　Socket：客户端套接字

　　　　ServerSocket：服务器端套接字

　　客户端基本步骤：

　　　　1.创建客户端套接字对象；

　　　　2.发起连接，并绑定连接地址；

　　　　3.获取输出流，写出数据；

　　　　4.通知服务器端数据写出完毕；

　　　　5.关闭套接字

 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 
 public class TCPClientDemo2 {
 
     public static void main(String[] args) throws Exception {
 
         // 创建客户端的套接字
         Socket s = new Socket();
 
         // 发起连接，绑定端口号
         s.connect(new InetSocketAddress("localhost", 8980));
 
         // 获取输出流
         OutputStream out = s.getOutputStream();
 
         // 写出数据
         out.write("我来啦啦啦~~~".getBytes());
 
         // 关闭输出流
         s.shutdownOutput();
 
         // 获取输入流
         InputStream in = s.getInputStream();
 
         // 读取数据
         byte[] bs = new byte[1024];
         int len = -1;
         while ((len = in.read(bs)) != -1) {
             System.out.println(new String(bs, 0, len));
         }
 
         // 通知服务器端数据已经读取完毕
         s.shutdownInput();
 
         // 关闭套接字
         s.close();
 
     }
 
 }

　　服务器端基本步骤：

　　　　1. 创建服务器端套接字，绑定端口号

　　　　2. 接受连接，获取到一个Socket对象

　　　　3. 获取输入流，读取数据

　　　　4. 通知客户端数据读取完毕

　　　　5. 关闭套接字

 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 
 public class TCPServerDemo {
 
     public static void main(String[] args) throws Exception {
 
         // 创建一个服务器端套接字对象---绑定端口号
         ServerSocket ss = new ServerSocket(9999);
 
         // 接受连接
         Socket s = ss.accept();
 
         // 获取一个输入流
         InputStream is = s.getInputStream();
 
         // 读取数据
         byte[] bs = new byte[1024];
         int len = -1;
         while ((len = is.read(bs)) != -1) {
             System.out.println(new String(bs, 0, len));
         }
 
         // 通知客户端数据读取完毕
         s.shutdownInput();
 
         // 关闭套接字
         s.close();
         ss.close();
 
     }
 
 }

注意：receive/connect/accept/read/write都会产生阻塞