Java NetWork笔记+作业

最新推荐文章于 2022-12-17 14:15:37 发布
最新推荐文章于 2022-12-17 14:15:37 发布
阅读量160 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java intellij-idea 网络 网络协议 udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxcsjf/article/details/125567426
版权

基本原理

 

 

UDP编程

传输原理

 

发送端步骤

  • 创建socket对象(DatagramSocket)

  • 把要发送的数据封装成数据报包

  • 通过send(数据报包)方法把数据报包发送出去

  • close释放资源

接收端步骤

  • 创建接收端的socket对象(DatagramSocket)

  • 创建用于接收的数据报包

  • 通过receive(数据报包)方法进行接收

  • 解析数据报包, 把数据从包里取出来

  • close释放资源

DatagramSocket

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

构造方法

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

成员方法

voidreceive(DatagramPacket p) 从此套接字接收数据报包。
voidsend(DatagramPacket p) 从此套接字发送数据报包。

DatagramPacket

此类表示数据报包

构造方法

用于发送的

 DatagramPacket(byte[] buf,  int offset, int length, InetAddress address, int port)        构造数据报包，用来将长度为 length 偏移量为 offset  的包发送到指定主机上的指定端口号。

用于接收的

 DatagramPacket(byte[] buf, int offset, int length) 
           构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。

成员方法

byte[]getData() 返回数据缓冲区。
intgetLength() 返回将要发送或接收到的数据的长度。
intgetOffset() 返回将要发送或接收到的数据的偏移量。

案例

v1 发送端发送消息,接收端接收并打印

 

package _22network.com.cskaoyan.udp.v1;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 /**
  * @description: 接收端
  * @author: 景天
  * @date: 2022/6/30 16:27
  **/
 ​
 public class Receiver {
     public static void main(String[] args) throws IOException {
         // - 创建接收端的socket对象(DatagramSocket)
         DatagramSocket datagramSocket = new DatagramSocket(9999);
         //- 创建用于接收的数据报包
         // DatagramPacket(byte[] buf, int offset, int length)
         // 构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。
         byte[] bytes = new byte[1024];
         DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);
 ​
         //- 通过receive(数据报包)方法进行接收
         System.out.println("receive before");
         datagramSocket.receive(receivePacket);
         System.out.println("receive after");
 ​
         //- 解析数据报包, 把数据从包里取出来
         byte[] data = receivePacket.getData();
         int offset = receivePacket.getOffset();
         int length = receivePacket.getLength();
         String s = new String(data, offset, length);
         System.out.println("接收到了来自"+receivePacket.getSocketAddress()+
                "的消息: " +s);
         //- close释放资源
         datagramSocket.close();
     }
 }
 ​
 ​
 package _22network.com.cskaoyan.udp.v1;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 ​
 /**
  * @description: 发送端
  * @author: 景天
  * @date: 2022/6/30 16:16
  **/
 ​
 /*
 v1 发送端发送消息,接收端接收并打印
  */
 public class Sender {
     public static void main(String[] args) throws IOException {
         // - 创建socket对象(DatagramSocket)
         DatagramSocket datagramSocket = new DatagramSocket(8888);
         //- 把要发送的数据封装成数据报包
         String s = "hello udp";
         // 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);
 ​
         //- 通过send(数据报包)方法把数据报包发送出去
         datagramSocket.send(sendPacket);
         //- close释放资源
         datagramSocket.close();
     }
 }
我的


package com._24_network._01_udp.ver1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * 发送端
 *
 * @author zxcsjf
 * @since 2022/06/30 19:18
 */
public class Sender {
    public static void main(String[] args) throws IOException {

        // 1.创建发送端的socket对象,port绑定本机端口
        DatagramSocket datagramSocket = new DatagramSocket(8888);

        // 2.把要发送的数据变成字节数组
        String s = "lalalalal~~~~";
        byte[] bytes = s.getBytes();

        // 3.得到目标ip
        InetAddress targetIP = InetAddress.getByName("192.168.13.255");
        // InetAddress localHost = InetAddress.getLocalHost();

        // 4.目标端口号
        int port = 9999;

        // 6.封装成数据报包
        DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, targetIP, port);

        // 7.通过send(包) 发送出去
        datagramSocket.send(datagramPacket);

        // 8.close
        datagramSocket.close();
    }
}

——————————————————————————————————————————————————————————————————————————————
package com._24_network._01_udp.ver1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * @author zxcsjf
 * @since 2022/06/30 19:29
 */
public class Receiver {
    public static void main(String[] args) throws IOException {
        // 1.创建接收端的socket对象
        DatagramSocket datagramSocket = new DatagramSocket(9999);

        // 2.创建用于存放数据的字符数组
        byte[] bytes = new byte[1024];

        // 3.创建用于接收数据的数据报包
        DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);

        // 4.调用socket的receive方法进行接收
        datagramSocket.receive(receivePacket);

        // 5.解析数据报包，把数据从包中取出，放入字符串
        byte[] data = receivePacket.getData();
        int offSet = receivePacket.getOffset();
        int length = receivePacket.getLength();
        String s = new String(data, offSet, length);
        System.out.println("接受到了来自" + receivePacket.getSocketAddress() + "的消息：" + s);

        // 6.释放资源，
        datagramSocket.close();

    }
}

 

v2 使用工具类优化v1

 

package _22network.com.cskaoyan.udp.v1;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 /**
  * @description: 接收端
  * @author: 景天
  * @date: 2022/6/30 16:27
  **/
 ​
 public class Receiver {
     public static void main(String[] args) throws IOException {
         // - 创建接收端的socket对象(DatagramSocket)
         DatagramSocket datagramSocket = new DatagramSocket(9999);
         //- 创建用于接收的数据报包
         // DatagramPacket(byte[] buf, int offset, int length)
         // 构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。
         byte[] bytes = new byte[1024];
         DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);
 ​
         //- 通过receive(数据报包)方法进行接收
         System.out.println("receive before");
         datagramSocket.receive(receivePacket);
         System.out.println("receive after");
 ​
         //- 解析数据报包, 把数据从包里取出来
         byte[] data = receivePacket.getData();
         int offset = receivePacket.getOffset();
         int length = receivePacket.getLength();
         String s = new String(data, offset, length);
         System.out.println("接收到了来自"+receivePacket.getSocketAddress()+
                "的消息: " +s);
         //- close释放资源
         datagramSocket.close();
     }
 }
 package _22network.com.cskaoyan.udp.v2;
 ​
 import utils.NetWorkUtils;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 /**
  * @description: 接收端
  * @author: 景天
  * @date: 2022/6/30 16:48
  **/
 ​
 public class Receiver {
     public static void main(String[] args) throws IOException {
         // 创建接收端的socket对象
         DatagramSocket datagramSocket = new DatagramSocket(9999);
         // 创建用于接收的数据报包
         DatagramPacket receivePacket = NetWorkUtils.getReceivePacket();
         // receive
         datagramSocket.receive(receivePacket);
         // 解析
         String msg = NetWorkUtils.parse(receivePacket);
         System.out.println(receivePacket.getSocketAddress()+":  " + msg);
         // close
         datagramSocket.close();
     }
 }
————————————————————————————————————————————————————————————————————————————————————————
package utils;

import java.io.Reader;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @description:
 * @author: 景天
 * @date: 2022/6/30 16:38
 **/

public 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 parse(DatagramPacket packet) {
        // 解析数据
        byte[] data = packet.getData();
        int offset = packet.getOffset();
        int length = packet.getLength();
        String s = new String(data, offset, length);
        return s;
    }
}

 ​

v3 发送端接收端相互发送

 package _22network.com.cskaoyan.udp.v3;
 ​
 import utils.NetWorkUtils;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.util.Scanner;
 ​
 /**
  * @description: 接收端
  * @author: 景天
  * @date: 2022/6/30 17:17
  **/
 ​
 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);
             // 解析
             String msg = NetWorkUtils.parse(receivePacket);
             System.out.println(msg);
 ​
             // 发送逻辑
             // 键盘接收数据
             String s = scanner.nextLine();
             // 把数据封装成数据报包
             DatagramPacket sendPacket =
                     NetWorkUtils.getSendPacket(s, "127.0.0.1", 8888);
             // send发送
             datagramSocket.send(sendPacket);
 ​
         }
     }
 }
 ​
 ​
 package _22network.com.cskaoyan.udp.v3;
 ​
 import utils.NetWorkUtils;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.util.Scanner;
 ​
 /**
  * @description: 发送端
  * @author: 景天
  * @date: 2022/6/30 17:12
  **/
 ​
 /*
 发送端接收端相互发送
  */
 public class Sender {
     public static void main(String[] args) throws IOException {
         // 创建发送端的socket对象
         DatagramSocket datagramSocket = new DatagramSocket(8888);
         // 创建Scanner对象
         Scanner scanner = new Scanner(System.in);
         // while循环
         while (true) {
             // 发送逻辑
             // 键盘接收数据
             String s = scanner.nextLine();
             // 把数据封装成数据报包
             DatagramPacket sendPacket =
                     NetWorkUtils.getSendPacket(s, "127.0.0.1", 9999);
             // send发送
             datagramSocket.send(sendPacket);
 ​
             // 接收逻辑
             // 创建用于接收的数据报包
             DatagramPacket receivePacket = NetWorkUtils.getReceivePacket();
             // receive方法接收
             datagramSocket.receive(receivePacket);
             // 解析
             String msg = NetWorkUtils.parse(receivePacket);
             System.out.println(msg);
 ​
         }
     }
 }
 ​

v4 使用多线程优化v3

思路:

 

OnePerson

AnotherPerson

定义2个任务

发送任务 只发送消息SendTask

  • 定义一个成员变量 DatagramSocket

  • ip

  • port

接收任务 只接收消息ReceiveTask

  • 定义一个成员变量 DatagramSocket

 package _22network.com.cskaoyan.udp.v4;
 ​
 import java.io.IOException;
 import java.net.DatagramSocket;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/6/30 17:42
  **/
 ​
 public class AnotherPerson {
     public static void main(String[] args) throws IOException {
         // 创建socket对象
         DatagramSocket datagramSocket = new DatagramSocket(9999);
         // 创建接收,发送任务
         // 运行在线程中
         new Thread(new SendTask(datagramSocket,"127.0.0.1",8888)).start();
         new Thread(new ReceiveTask(datagramSocket)).start();
     }
 }
 ​
 ​
 ​
 ​
 package _22network.com.cskaoyan.udp.v4;
 ​
 import java.io.IOException;
 import java.net.DatagramSocket;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/6/30 17:42
  **/
 ​
 public class OnePerson {
     public static void main(String[] args) throws IOException {
         // 创建socket对象
         DatagramSocket datagramSocket = new DatagramSocket(8888);
         // 创建接收,发送任务
         // 运行在线程中
         new Thread(new SendTask(datagramSocket,"127.0.0.1",9999)).start();
         new Thread(new ReceiveTask(datagramSocket)).start();
     }
 }
 ​
 ​
 ​
 ​
 package _22network.com.cskaoyan.udp.v4;
 ​
 import utils.NetWorkUtils;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 ​
 /**
  * @description: 接收消息的任务
  * @author: 景天
  * @date: 2022/6/30 17:39
  **/
 ​
 public class ReceiveTask implements Runnable{
     // 定义一个成员变量 DatagramSocket
     DatagramSocket datagramSocket;
 ​
     public ReceiveTask(DatagramSocket datagramSocket) {
         this.datagramSocket = datagramSocket;
     }
 ​
     @Override
     public void run() {
         // 只接收消息
         while (true) {
             // 创建用于接收的数据报包
             DatagramPacket receivePacket = NetWorkUtils.getReceivePacket();
             // receive方法接收数据
             try {
                 datagramSocket.receive(receivePacket);
                 // parse
                 String msg = NetWorkUtils.parse(receivePacket);
                 // 打印
                 System.out.println("接收到了来自" +
                         receivePacket.getSocketAddress() +
                         "的消息: " + msg);
 ​
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 ​
 ​
 package _22network.com.cskaoyan.udp.v4;
 ​
 import utils.NetWorkUtils;
 ​
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.UnknownHostException;
 import java.util.Scanner;
 ​
 /**
  * @description: 发送任务
  * @author: 景天
  * @date: 2022/6/30 17:35
  **/
 ​
 /*
 - 定义一个成员变量 DatagramSocket
 - ip
 - port
  */
 public class SendTask implements Runnable{
     // 定义成员变量
     DatagramSocket datagramSocket;
     String ip;
     int port;
 ​
     public SendTask(DatagramSocket datagramSocket, String ip, int port) {
         this.datagramSocket = datagramSocket;
         this.ip = ip;
         this.port = port;
     }
 ​
     @Override
     public void run() {
         // 创建Scanner对象
         Scanner scanner = new Scanner(System.in);
         // 只发送消息
         while (true) {
             // 键盘接收数据
             String msg = scanner.nextLine();
             // 把数据封装成数据报包
             try {
                 DatagramPacket sendPacket =
                         NetWorkUtils.getSendPacket(msg, ip, port);
                 // send
                 datagramSocket.send(sendPacket);
             } catch (UnknownHostException e) {
                 e.printStackTrace();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 ​

TCP编程

传输原理

 

 

客户端步骤(Client)

  • 创建客户端socket对象

  • 从socket对象中获取输入输出流

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

  • close释放资源

服务端步骤(Server)

  • 创建服务端socket对象(ServerSocket)

  • 利用accept方法建立连接,得到socket对象

  • 从socket对象中获取输入输出流

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

  • close释放资源

Socket

此类实现客户端套接字

构造方法

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

成员方法

InputStreamgetInputStream() 返回此套接字的输入流。
OutputStreamgetOutputStream() 返回此套接字的输出流。

Socket半关闭

voidshutdownOutput() 禁用此套接字的输出流。

ServerSocket

此类实现服务器套接字

构造方法

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

成员方法

Socketaccept() 侦听并接受到此套接字的连接。

案例

v1 客户端发送消息,服务端接收并打印

 package _22network.com.cskaoyan.tcp.v1;
 ​
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.Socket;
 ​
 /**
  * @description: 客户端
  * @author: 景天
  * @date: 2022/7/1 9:46
  **/
 ​
 /*
 客户端发送消息,服务端接收并打印
  */
 public class Client {
     public static void main(String[] args) throws IOException {
         // 创建客户端socket对象
         Socket socket = new Socket("127.0.0.1", 9999);
 ​
         // 获取输出流
         OutputStream out = socket.getOutputStream();
 ​
         // write数据
         out.write("hello tcp".getBytes());
 ​
         // close
         out.close();
     }
 }
 ​
 ​
 ​
 package _22network.com.cskaoyan.tcp.v1;
 ​
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 /**
  * @description: 服务端
  * @author: 景天
  * @date: 2022/7/1 9:49
  **/
 ​
 public class Server {
     public static void main(String[] args) throws IOException {
         //  创建服务端socket对象
         ServerSocket serverSocket = new ServerSocket(9999);
         // 建立连接  accept方法  --> socket对象
         System.out.println("accept before");
         Socket socket = serverSocket.accept();
         System.out.println("accept after");
 ​
         // 从socket对象中获取输入流
         InputStream in = socket.getInputStream();
         // read读取数据
         byte[] bytes = new byte[1024];
         int readCount = in.read(bytes);
         String s = new String(bytes, 0, readCount);
         System.out.println(socket.getInetAddress() +"--"+socket.getPort()+ "--" + s);
         // close
         socket.close();
         serverSocket.close();
     }
 }
 ​

v2 多个客户端发送,服务端接收(多线程处理)

 

package _22network.com.cskaoyan.tcp.v2;
 ​
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 ​
 /**
  * @description: 服务端
  * @author: 景天
  * @date: 2022/7/1 10:06
  **/
 ​
 public class Server {
     public static void main(String[] args) throws IOException {
         // 创建服务端socket对象
         ServerSocket serverSocket = new ServerSocket(8888);
         // 创建线程池
         ExecutorService pool = Executors.newFixedThreadPool(2);
         // 循环
         while (true) {
             // 建立连接 得到Socket对象
             Socket socket = serverSocket.accept();
             //new Thread(new ConnectTask(socket)).start();
             // 使用线程池
             pool.submit(new ConnectTask(socket));
 ​
         }
     }
 }
 ​
 class ConnectTask implements Runnable{
 ​
     // 定义成员变量
     Socket socket;
 ​
     public ConnectTask(Socket socket) {
         this.socket = socket;
     }
 ​
     @Override
     public void run() {
         while (true) {
             // 读取来自客户端的数据
             try {
                 // 获取输入流
                 InputStream in = socket.getInputStream();
                 // read读一下
                 byte[] bytes = new byte[1024];
                 int readCount = in.read(bytes);
                 String s = new String(bytes, 0, readCount);
                 System.out.println(socket.getInetAddress() + ":" + socket.getPort() +
                         "--" + Thread.currentThread().getName() + s);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 ​
 ​
 package _22network.com.cskaoyan.tcp.v2;
 ​
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.util.Scanner;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/7/1 9:58
  **/
 ​
 /*
  多个客户端发送,服务端接收(多线程处理)
  */
 public class Client {
     public static void main(String[] args) throws IOException {
         // 创建客户端socket对象
         Socket socket = new Socket("127.0.0.1", 8888);
         // 创建Scanner对象
         Scanner scanner = new Scanner(System.in);
         // while循环
         while (true) {
             // 键盘接收数据
             String s = scanner.nextLine();
             // 从socket中获取输出流
             OutputStream out = socket.getOutputStream();
             out.write(s.getBytes());
 ​
         }
     }
 }
 ​

v3 客户端发送对象(序列化),服务端接收

 

package _22network.com.cskaoyan.tcp.v3;
 ​
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/7/1 10:24
  **/
 ​
 public class Server {
     public static void main(String[] args) throws IOException, ClassNotFoundException {
         // 创建服务端Socket对象
         ServerSocket serverSocket = new ServerSocket(12306);
         // 跟客户端建立连接
         Socket socket = serverSocket.accept();
         // 得到socket对象
 ​
         // 从socket中获取输入流
         InputStream in = socket.getInputStream();
 ​
         // 利用反序列流进行包装
         ObjectInputStream objectInputStream = new ObjectInputStream(in);
 ​
         // readObject读取对象
         Object o = objectInputStream.readObject();
 ​
         // 打印
         System.out.println(o);
 ​
         // close
         socket.close();
         serverSocket.close();
     }
 }
 ​
 ​
 ​
 ​
 package _22network.com.cskaoyan.tcp.v3;
 ​
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/7/1 10:20
  **/
 ​
 /*
 v3 客户端发送对象(序列化),服务端接收
  */
 public class Client {
     public static void main(String[] args) throws IOException {
         // 创建客户端Socket对象
         Socket socket = new Socket("127.0.0.1", 12306);
         // 创建学生对象
         Student student = new Student("zs", 20);
         // 从Socket中获取输出流
         OutputStream out = socket.getOutputStream();
         // 利用序列化流进行包装
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);
 ​
         // writeObject(学生对象)
         objectOutputStream.writeObject(student);
 ​
         // close
         socket.close();
     }
 }

v4 客户端上传文件到服务端

思路:

package _22network.com.cskaoyan.tcp.v4;
 ​
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 ​
 /**
  * @description:
  * @author: 景天
  * @date: 2022/7/1 10:59
  **/
 ​
 /*
 客户端上传文件到服务端
  */
 public class Client {
     public static void main(String[] args) throws IOException {
         // 创建客户端的socket对象
         Socket socket = new Socket("127.0.0.1", 11111);
         // 创建自己的输入流对象
         FileInputStream in = new FileInputStream("D:\\b.txt");
         // 从socket中获取输出流
         OutputStream out = socket.getOutputStream();
         // 边读边写
         int readCount;
         byte[] bytes = new byte[1024];
         while ((readCount = in.read(bytes)) != -1) {
             out.write(bytes,0,readCount);
         }
 ​
         // 循环结束意味着文件已经上传到服务器
         System.out.println("客户端已经上传完毕");
         // 禁用此套接字的输出流 shutdownOutput()
         socket.shutdownOutput();
 ​
         // 接收来自服务端的反馈消息
         // 从socket中获取输入流
         InputStream inputStream = socket.getInputStream();
         // 读取数据
         byte[] bytes1 = new byte[1024];
         System.out.println("read before");
         int readCount2 = inputStream.read(bytes1);
         System.out.println("read after");
 ​
         System.out.println(new String(bytes1,0,readCount2));
 ​
         // close
         in.close();
         socket.close();
     }
 }
 ​
 ​
 ​
 package _22network.com.cskaoyan.tcp.v4;
 ​
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 ​
 /**
  * @description: 服务端
  * @author: 景天
  * @date: 2022/7/1 11:03
  **/
 ​
 public class Server {
     public static void main(String[] args) throws IOException {
         // 创建服务端socket对象
         ServerSocket serverSocket = new ServerSocket(11111);
         // 创建自己的输出流对象
         FileOutputStream out = new FileOutputStream("copy_b.txt");
         // accept建立连接 得到socket对象
         Socket socket = serverSocket.accept();
         // 从socket获取输入流
         InputStream in = socket.getInputStream();
         // 边读边写
         int readCount;
         byte[] bytes = new byte[1024];
         while ((readCount = in.read(bytes)) != -1) {
             out.write(bytes,0,readCount);
         }
         System.out.println("end while");
         // 保存成功
         // 给客户端一个反馈消息
         // 从socket中获取输出流
         OutputStream outputStream = socket.getOutputStream();
         // write
         outputStream.write("文件上传成功!".getBytes());
         // close
         out.close();
         socket.close();
         serverSocket.close();
     }
 }
 ​

异常

java.net.ConnectException: Connection refused: connect 先启动了Client

java.net.BindException: Address already in use: JVM_Bind port重复了

作业：

zxc单飞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现将共享文件
bobo_supper的博客
10-12 1010
依赖注入 <!--网络共享内文件传输--> <!--java连接共享文件夹--> <dependency> <groupId>org.samba.jcifs</groupId> <artifactId>jcifs</artifactId> <version>1.3.14-kohsuke-1&.
JAVA network
yingzhengttt blog
03-11 315
socket Get connecting Main methods: 1. Socket(host,port); 2. connect(SocketAddress address,int timeout); 3. s.setSoTimeout(int timeout); 4. s.isConnect() 5. s.isClosed() eg: package socket; import j...
I/O复习(三)——Java Network
stepMore的博客
04-20 582
InetAddress java.net.InetAddress类是Java对IP地址的高层表示。大多数其他网络类都要用到这个类，包括Socket、ServerSocket、URL、DatagramSocket、DatagramPacket等。一般地讲，它包括一个主机名和一个IP地址。 InetAddress address = InetAddress.getByName("www.baidu....
Java网络编程学习笔记 NetworkInterface
走马观花
12-17 1417
NetworkInterface类表示一个由名称例如“eth0”、“net2”和分配给此接口的IP地址列表组成的网络接口。该类提供访问网卡设备的相关信息，例如可以获取网卡名称、IP地址和子网掩码等。
java websocket 接收_【译】 WebSocket 协议第六章——发送与接收消息（Sending and Receiving Data）...
weixin_34664586的博客
02-13 582
概述本文为 WebSocket 协议的第六章，本文翻译的主要内容为 WebSocket 消息发送与接收相关内容。发送与接收消息(协议正文)6.1 发送数据为了通过 WebSocket 连接发送一条 WebSocket 消息，终端必须遵循以下几个步骤：终端必须保证 WebSocket 连接处于 OPEN 状态(见第 4.1 节和第 4.2.2 节)。如果 WebSocket 连接的任意一端的状态发生...
Java Network Programming 4th Edition
12-30
little surprising that network programming in Java remains so mysterious to so many. It doesn’t have to be. In fact, writing network programs in Java is quite simple, as this book will show. Readers ...
Java Network Programming
06-17
It is a clear, complete introduction to developing network programs (both applets and applications) using Java, covering everything from networking fundamentals to remote method invocation (RMI)....
java network programming 4th edition pdf
07-27
little surprising that network programming in Java remains so mysterious to so many. It doesn’t have to be. In fact, writing network programs in Java is quite simple, as this book will show. Readers ...
Java Network Programming 4th 原版pdf by Harold
04-28
little surprising that network programming in Java remains so mysterious to so many. It doesn’t have to be. In fact, writing network programs in Java is quite simple, as this book will show. Readers ...
Network+ Guide to Networks(7th) 无水印pdf
09-27
Network+ Guide to Networks(7th) 英文无水印pdf 第7版 pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请...
java network
08-20
java network 开发技术升级专用，有助于java技术的提升
java network_Java network program （Java 网络编程学习心得）
weixin_28976245的博客
02-21 115
转载请标明出处作者的话最近有同学问我Java网络编程方面的知识，我就总结了一篇关于网络知识由初级到中级的学习过程。其中这本书是非常有阅读学习的价值。我下载了电子版的中文翻译版，英文的也能看懂，但对于现在的我效率慢的多，大概是英文词汇量不够足的原因。接下来就把学习此书的过程中遇到的知识点都一一记录下来，回头温习或者研磨这一块儿时不必从头开始。好脑子不如烂笔头嘛~(次文会不断更新)JavaI/O 中 ...
Java - 网络编程(NetWork)
weixin_30553065的博客
11-23 150
Java -网络编程(NetWork) 一、java.net包下的 InetAddress 类的使用： > 一个 InetAddress 代表着一个IP地址 > 主要用来查看本机的IP和主机名 1、方法介绍： >InetAddressinet =InetAddress.getByName("www.baidu.com");：调...
Java——NetWork（一）
Lucifer的博客
08-25 2138
-_-直接从多线程就蹦到Network部分了，绝对不是因为我懒！！！ 其实身为软件工程专业的一个小白，从大二的计算机网络开始就天天听老师念叨socket编程，后来选修了TCP/IP协议与网络编程又是天天说socket编程，可是这些老师总是天天说socket编程也从来没有讲过啥是个socket…以至于我一直觉得这个东西十分的神秘。下面说一下在java中的socket编程是什么样的。（内容摘取自网络如
java network_JAVA NetworkInterface类静态方法
weixin_33900596的博客
02-21 204
importjava.net.InetAddress;importjava.net.NetworkInterface;importjava.net.SocketException;importjava.net.UnknownHostException;importjava.util.Enumeration;public classnetworkInterfaceStaticMethod {publ...
java.net.NetworkInterface
书香水墨
05-11 7415
此类表示由名称和分配给此接口的IP地址列表组成的网络接口。它用于标识多播组加入的本地接口。接口通常以诸如“le0”之类的名称而为人所知。 方法 描述 boolean equals(Object obj) 将此对象与指定的对象进行比较。 static NetworkInterface getByIndex(int index) 根据索引获取网络接口。 static Net...
Java网络通信常用类介绍(Java.net包)
pengkv的专栏
12-18 9774
InetAddress类:表示互联网协议 (IP) 地址 URL类:代表一个统一资源定位符，它是指向互联网“资源”的指针。    资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。 URLConnection类:用于读取和写入此 URL 引用的资源。 使用步骤: 通过在 URL 上调用 openConnection 方法
java network_Java Network Programming, Third Edition
weixin_39717704的博客
02-21 77
The new third edition of this highly regarded introduction to Java networking programming has been thoroughly revised to cover all of the 100+ significant updates to Java Developers Kit (JDK) 1.5. It ...
Java Network Programming 笔记(1)
聚焦游戏和图形引擎开发技术
06-24 2493
Java Network Programming 笔记n5一 网络基本概念Chapter2 Basic Network Concepts2.1 Networkskeywords： network, node, host, address, name, packet-switched, protocol网络是可以或多或少实时地相互发送和接收数据的计算机和其他设备的集合。网络上的每台机器被称作结点(n
java network api
最新发布
05-27
Java 网络 API 是 Java 中用于处理网络通信的一套 API，主要包括 java.net 和 java.nio 两个包。其中，java.net 包提供了基于传统的阻塞式 I/O 的网络编程接口，而 java.nio 包则提供了基于非阻塞式 I/O 的网络编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值