网络数据传输的基本原理

• ip地址
  • 唯一确定目的主机
• port 端口号
  • 唯一确定进程
• 协议
  • UDP协议：无连接的不可靠的协议
  • TCP协议：面向连接的可靠的协议

---

UDP

发送端步骤

1. 创建发送端的socket对象
2. 把要发送的数据封装成数据报包
3. send方法发送数据报包
4. 释放资源close

接收端步骤

1. 创建接收端的socket对象
2. 创建用于接收的数据报包
3. receive方法接收数据
4. 解析数据报包
5. 释放资源close

DatagramSocket

此类表示用来发送和接收数据报包的套接字。

构造方法：

DatagramSocket(int port)     //  创建数据报套接字并将其绑定到本地主机上的指定端口。

成员方法：

DatagramPacket

此类表示数据报包。

构造方法

1. 用于发送的
DatagramPacket(byte[] buf,  int offset, int length, InetAddress address, int port)      
// 构造数据报包，用来将长度为 length 偏移量为 offset  的包发送到指定主机上的指定端口号
// InetAddress address ---> ip值2. 用于接受的
DatagramPacket(byte[] buf,  int offset, int length)      
// 构造DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。

成员方法：

举例

版本1：发送端发送消息,接收端接收并打印

// 发送端sender
public class Sender {public static void main(String[] args) throws IOException {//   1. 创建发送端的socket对象DatagramSocket datagramSocket = new DatagramSocket(8888);//   2. 把要发送的数据封装成数据报包String s = "hello";// DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)// 构造数据报包，用来将长度为 length 偏移量为 offset  的包发送到指定主机上的指定端口号byte[] bytes = s.getBytes();InetAddress targetIP = InetAddress.getByName("127.0.0.1");int port = 9999;DatagramPacket sendPacket =new DatagramPacket(bytes, 0, bytes.length, targetIP, port);//   3. send方法发送数据报包datagramSocket.send(sendPacket);//   4. 释放资源closedatagramSocket.close();}
}———————————————————————————————————————————————————————————————————————————————————————————// 接收端receiver
public class Receiver {public static void main(String[] args) throws IOException {// 1. 创建接收端的socket对象DatagramSocket datagramSocket = new DatagramSocket(9999);// 2. 创建用于接收的数据报包// DatagramPacket(byte[] buf,  int offset, int length)// 构造DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。byte[] bytes = new byte[1024];DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);// 3. receive方法接收数据System.out.println("receiver before");datagramSocket.receive(receivePacket);System.out.println("receiver after");// 4. 解析数据报包byte[] data = receivePacket.getData();int length = receivePacket.getLength();int offset = receivePacket.getOffset();System.out.println(new String(data, offset, length));// 5. 释放资源closedatagramSocket.close();}
}

版本2：创建一个NetworkUtils工具类优化版本1

NetworkUtil.javapublic class NetworkUtils {// 提供一个获取发送数据报包的方法public static DatagramPacket getSendPacket(String msg, String ip, int port) throws UnknownHostException {// 把数据封装到包里byte[] bytes = msg.getBytes();InetAddress targetIP = InetAddress.getByName(ip);DatagramPacket sendPacket = new DatagramPacket(bytes, 0, bytes.length, targetIP, port);return sendPacket;}// 提供一个获取接受数据报包的方法public static DatagramPacket getReceivePacket() {// 创建接收数据报的包byte[] bytes = new byte[1024];DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);return receivePacket;}// 提供一个解析数据报包的方法public static String parseMsg(DatagramPacket receivePacket) {byte[] bytes = receivePacket.getData();int length = receivePacket.getLength();int offset = receivePacket.getOffset();return new String(bytes,offset,length);}
}————————————————————————————————————————————————————————————————————————————————————————————// sender 发送端
public class Sender {public static void main(String[] args) throws IOException {DatagramSocket datagramSocket = new DatagramSocket(8888);String s = "hello hi";DatagramPacket sendPacket = NetworkUtils.getSendPacket(s, "127.0.0.1", 9999);datagramSocket.send(sendPacket);datagramSocket.close();}
}————————————————————————————————————————————————————————————————————————————————————————————// 接收端receiverpublic class Receiver {public static void main(String[] args) throws IOException {DatagramSocket datagramSocket = new DatagramSocket(9999);DatagramPacket receivePacket = NetworkUtils.getReceivePacket();datagramSocket.receive(receivePacket);String s = NetworkUtils.parseMsg(receivePacket);System.out.println(s);datagramSocket.close();}
}

版本3：发送端接收端相互发送

// 发送端sender
public class Sender {public static void main(String[] args) throws IOException {// 1. 创建发送端的socket对象DatagramSocket datagramSocket = new DatagramSocket(8888);// 2. 创建Scannner对象Scanner scanner = new Scanner(System.in);// while循环while (true) {// 3. 发送逻辑// 键盘接收数据String s = scanner.nextLine();// 把数据封装成数据包DatagramPacket sendPacket = NetworkUtils.getSendPacket(s, "127.0.0.1", 9999);// senddatagramSocket.send(sendPacket);// 4. 接受逻辑// 创建用于接受的数据报包DatagramPacket receivePacket = NetworkUtils.getReceivePacket();// receive方法接收datagramSocket.receive(receivePacket);// 解析String s1 = NetworkUtils.parseMsg(receivePacket);System.out.println("接收到了" + receivePacket.getSocketAddress() + "的消息" + s1);}}
}// 接收端 receiver
public class Receiver {public static void main(String[] args) throws IOException {// 创建接收端的Socket对象DatagramSocket datagramSocket = new DatagramSocket(9999);// 创建Scanner对象Scanner scanner = new Scanner(System.in);// while循环while (true) {// 接受逻辑// 创建用于接受的数据报包DatagramPacket receivePacket = NetworkUtils.getReceivePacket();// receive接受datagramSocket.receive(receivePacket);// parse解析String msg = NetworkUtils.parseMsg(receivePacket);System.out.println("接收到了" + receivePacket.getSocketAddress() + "的消息" + msg);// 发送逻辑// 键盘接收数据String s = scanner.nextLine();// 把数据封装成包DatagramPacket sendPacket = NetworkUtils.getSendPacket(s, "127.0.0.1", 8888);// senddatagramSocket.send(sendPacket);}}
}

版本4：使用多线程

• 定义发送任务 SendTask 专门用来发送消息
• 定义接收任务 receiveTask 专门用来接收消息

eg：

SendTask:
public class SenderTask implements Runnable {// DatagramSocket datagramSocketDatagramSocket datagramSocket;// String ipString ip;// int portint port;public SenderTask(DatagramSocket datagramSocket, String ip, int port) {this.datagramSocket = datagramSocket;this.ip = ip;this.port = port;}@Overridepublic void run() {// 创建Scanner对象Scanner scanner = new Scanner(System.in);// whilewhile(true){// 键盘输入消息String s = scanner.nextLine();// 把消息封装成数据报包try {DatagramPacket sendPacket = NetworkUtils.getSendPacket(s, ip, port);// senddatagramSocket.send(sendPacket);} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}
}ReceiveTask:
public class ReceiveTask implements Runnable{// 成员变量DatagramSocket datagramSocket;public ReceiveTask(DatagramSocket datagramSocket) {this.datagramSocket = datagramSocket;}@Overridepublic void run() {// 只是接收数据while(true){// 创建用于接收的数据报包DatagramPacket receivePacket = NetworkUtils.getReceivePacket();// receive接收try {datagramSocket.receive(receivePacket);// 解析String s = NetworkUtils.parseMsg(receivePacket);// 打印System.out.println("s = " + s);} catch (IOException e) {e.printStackTrace();}}}
}OnePerson:
public class OnePerson {public static void main(String[] args) throws IOException {// 创建DatagramSocket对象DatagramSocket datagramSocket = new DatagramSocket(8888);// 创建发送线程 接收线程并启动new Thread(new SenderTask(datagramSocket,"127.0.0.1",9999)).start();// 创建接收线程new Thread(new ReceiveTask(datagramSocket)).start();}
}AnotherPerson：
public class AnotherPerson {public static void main(String[] args) throws IOException {// 创建DatagramSocket对象DatagramSocket datagramSocket = new DatagramSocket(9999);// 创建发送线程 接收线程并启动new Thread(new SenderTask(datagramSocket, "127.0.0.1", 8888)).start();// 创建接收线程new Thread(new ReceiveTask(datagramSocket)).start();}
}

---

TCP

客户端步骤

1. 创建客户端Socket对象(Socket)

2. 从socket中获取输入输出流

3. 利用输出输出流进行读写操作

4. 释放资源close

服务端步骤

1. 创建服务端的socket对象(ServerSocket)

2. 通过accept建立连接, 得到socket对象

3. 从socket中得到输入输出流

4. 利用输入输出流进行读写操作

5. 释放资源

Socket

此类实现客户端套接字

构造方法：

Socket(String host,  int port)       
// 创建一个流套接字并将其连接到指定主机上的指定端口号。

注：这里的host指的是目的主机的指定端口

成员方法：

• 
• 

ServerSocket

此类实现服务器套接字

构造方法：

ServerSocket(int port)        
// 创建绑定到特定端口的服务器套接字。

成员方法：

• 

举例

版本1：客户端发送消息，服务端接收并打印

注意事项：

• 先启动服务端，后启动客户端
• 端口号不能重复，如果重复占用的话，换一个端口号

eg：

客户端Client：
public class Client {public static void main(String[] args) throws IOException {// 1. 创建客户端Socket对象// Socket(String host,  int port)Socket socket = new Socket("127.0.0.1", 9999);// 2. 从socket中获取输入输出流OutputStream out = socket.getOutputStream();// 3. 利用输出输出流进行读写操作out.write("hello".getBytes());// 4. 释放资源closesocket.close();}
}服务端Server：
public class Server {public static void main(String[] args) throws IOException {// 1. 创建服务端的socket对象(ServerSocket)// ServerSocket(int port)ServerSocket serverSocket = new ServerSocket(9999);// 2. 通过accept建立连接, 得到socket对象Socket socket = serverSocket.accept();// 3. 从socket中得到输入输出流InputStream inputStream = socket.getInputStream();// 4. 利用输入输出流进行读写操作byte[] bytes = new byte[1024];int readCount = inputStream.read(bytes);System.out.println(new String(bytes, 0, readCount));// 5. 释放资源serverSocket.close();socket.close();}
}

版本2：多个客户端发送,服务端接收(多线程处理)

eg：

客户端Client：
public class Client {public static void main(String[] args) throws IOException {// 创建客户端的socket对象Socket socket = new Socket("127.0.0.1",9999);// 创建scanner对象Scanner scanner = new Scanner(System.in);// while循环while(true){String s = scanner.nextLine();// 从socket对象中获取输入输出流// 字节流OutputStream out = socket.getOutputStream();// 转换成字符流OutputStreamWriter outputStreamWriter = new OutputStreamWriter(out);// write
//            out.write(s.getBytes());outputStreamWriter.write(s);// flushoutputStreamWriter.flush();}}
}服务端Server：
public class Server {public static void main(String[] args) throws IOException {// 创建服务端的socket对象ServerSocket serverSocket = new ServerSocket(9999);// 创建线程池ExecutorService pool = Executors.newFixedThreadPool(2);// while循环while (true){// 通过accept方法建立连接Socket socket = serverSocket.accept();// 向线程池中提交任务pool.submit(new ConnectTask(socket));// 使用多线程// new Thread(new ConnectTask(socket)).start();}}
}// 多线程改进
class ConnectTask implements Runnable{// 定义成员变量Socket socket;public ConnectTask(Socket socket) {this.socket = socket;}@Overridepublic void run() {// 读取数据while (true){try {InputStream in = socket.getInputStream();byte[] bytes = new byte[1024];int readCount = in.read(bytes);String s = new String(bytes, 0, readCount);System.out.println("接收到了来自" + socket.getLocalAddress()+ "端口号是：" + socket.getPort()+ "线程名是：" + Thread.currentThread().getName()+ "，内容是：" + s);} catch (IOException e) {e.printStackTrace();}}}
}

版本3：客户端发送对象(序列化),服务端接收

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。
可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

eg：

客户端Client：
public class Client {public static void main(String[] args) throws IOException {// 创建客户端socket对象Socket socket = new Socket("127.0.0.1", 12300);// 从socket中获取输出流OutputStream out = socket.getOutputStream();// 把输出流进行包装，包装成序列化流ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);// 创建学生对象Student student = new Student("zs", 20);// writeObjectobjectOutputStream.writeObject(student);// closeobjectOutputStream.close();socket.close();}
}服务端Server：
public class Server {public static void main(String[] args) throws IOException, ClassNotFoundException {// 创建客户端的socket对象ServerSocket serverSocket = new ServerSocket(12300);// accept方法建立连接，得到socket对象Socket socket = serverSocket.accept();// 得到输入流InputStream in = socket.getInputStream();// 把输入流进行包装 ObjectInputStreamObjectInputStream objectInputStream = new ObjectInputStream(in);// readObjectObject o = objectInputStream.readObject();// 打印System.out.println(o);// closeobjectInputStream.close();socket.close();serverSocket.close();}
}

版本4：客户端上传文件到服务端

eg：

客户端Client：
// 客户端上传文件到服务端
public class Client {public static void main(String[] args) throws IOException {// 创建客户端的socket对象Socket socket = new Socket("127.0.0.1", 12345);// 创建自己的输入流对象FileInputStream fileInputStream = new FileInputStream("D:\\Java_test\\testPhoto.jpg");// 通过自己的输入流读取文件信息OutputStream outputStream = socket.getOutputStream();// 通过socket获取输出流对象int readCount;byte[] bytes = new byte[1024];while ((readCount = fileInputStream.read(bytes)) != -1) {// 边读边写outputStream.write(bytes, 0, readCount);}// 释放资源fileInputStream.close();outputStream.close();socket.close();}
}服务端Server：
public class Server {public static void main(String[] args) throws IOException {// 创建服务端的socket对象ServerSocket serverSocket = new ServerSocket(12345);// 创建自己的输出流对象FileOutputStream fileOutputStream = new FileOutputStream("D:\\darkNight.jpg");// accept方法建立连接 得到socket对象Socket socket = serverSocket.accept();// 从socket中获取输入流InputStream in = socket.getInputStream();// 边读边写int readCount;byte[] bytes = new byte[1024];while ((readCount = in.read(bytes)) != -1) {fileOutputStream.write(bytes, 0, readCount);}// 释放serverSocket.close();socket.close();fileOutputStream.close();in.close();}
}

• 
  Socket的半关闭

版本4plus：

eg：

客户端Client：
public class Server {public static void main(String[] args) throws IOException {// 创建服务端的socket对象ServerSocket serverSocket = new ServerSocket(12345);// 创建自己的输出流对象FileOutputStream fileOutputStream =new FileOutputStream("D:\\darkNight.jpg");// accept方法建立连接 得到socket对象Socket socket = serverSocket.accept();// 从socket中获取输入流InputStream in = socket.getInputStream();// 边读边写int readCount;byte[] bytes = new byte[1024];while ((readCount = in.read(bytes)) != -1) {fileOutputStream.write(bytes, 0, readCount);}OutputStream outputStream = socket.getOutputStream();outputStream.write("文件上传成功".getBytes());// 释放serverSocket.close();socket.close();fileOutputStream.close();in.close();}
}服务端Server：
public class Server {public static void main(String[] args) throws IOException {// 创建服务端的socket对象ServerSocket serverSocket = new ServerSocket(12345);// 创建自己的输出流对象FileOutputStream fileOutputStream =new FileOutputStream("D:\\darkNight.jpg");// accept方法建立连接 得到socket对象Socket socket = serverSocket.accept();// 从socket中获取输入流InputStream in = socket.getInputStream();// 边读边写int readCount;byte[] bytes = new byte[1024];while ((readCount = in.read(bytes)) != -1) {fileOutputStream.write(bytes, 0, readCount);}OutputStream outputStream = socket.getOutputStream();outputStream.write("文件上传成功".getBytes());// 释放serverSocket.close();socket.close();fileOutputStream.close();in.close();}
}

---