Java——TCP UDP Socket编程

已于 2023-11-10 17:00:01 修改
阅读量48 收藏
点赞数
文章标签： tcp/ip tcp
于 2023-11-09 16:05:48 首次发布
原文链接：https://blog.csdn.net/m0_62946761/article/details/130795291
版权

目录

一、网络的相关概念

（一）网络通信

（二）网络

（三）ip地址

（四）ipv4地址分类

（五）域名

（六）网络通信协议

（七）TCP和UDP

二、InetAddress类

三、Socket

四、TCP网络编程

（一）案例一——使用字节流

（二）案例二——使用字节流 

（三）案例三——使用字符流

（四）案例四——使用字符流

五、UDP网络编程

（一）基本介绍

（二）基本流程

（三）案例

六、案例

（一）案例一

（二）案例二

一、网络的相关概念
（一）网络通信
1.概念:两台设备之间通过网络实现数据传输

2.网络通信:将数据通过网络从一台设备传输到另一台设备

3.java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

（二）网络
1.概念:两台或多台设备通过一定物理设备连接起来构成了网络
2.根据网络的覆盖范围不同，对网络进行分类:

局域网: 覆盖范围最小，仅仅覆盖一个教室或一个机房
城域网:覆盖范围较大，可以覆盖一个城市
广域网:覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表


（三）ip地址
1.概念: 用于唯一标识网络中的每台计算机/主机

2.查看ip地址: ipconfig

3.ip地址的表示形式:点分十进制 xx.xx.xx.xx

4.每一个十进制数的范围: 0~255
5.ip地址的组成=网络地址+主机地址，比如: 192.168.16.69

6.lPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址

7.由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

（四）ipv4地址分类


（五）域名
1.比如www.baidu.com，将ip映射到域名上，访问域名就是访问ip
2.好处:为了方便记忆，解决记ip的困难


端口号

1.概念: 用于标识计算机上某个特定的网络程序

2.表示形式: 以整数形式，端口范围0~65535 [2个字节表示端口 0~2^16-1]

3.0~1024已经被占用, 比如 ssh 22, ftp 21, smtp 25 http 80

4.常见的网络程序端口号:

tomcat :8080
mysql:3306
oracle:1521
sqlserver:1433
（六）网络通信协议


协议(tcp/ip)

TCP/IP (Transmission Control Protocol/Internet Protocol)的简写, 中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

（七）TCP和UDP
TCP协议: 传输控制协议
1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用“三次握手"方式，是可靠的

3.TCP协议进行通信的两个应用进程: 客户端、服务端

4.在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP协议: 用户数据协议
1.将数据、源、目的封装成数据包，不需要建立连接

2.每个数据报的大小限制在64K内,不适合传输大量数据

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

5.举例: 发短信

二、InetAddress类
方法：

获取本机InetAddress对象 getLocalHost
根据指定主机名/域名获取ip地址对象 getByName
获取InetAddress对象的主机名 getHostName
获取InetAddress对象的地址 getHostAddress
/*
 * 演示InetAddress类的使用
 */
public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        // 1.获取本机的InetAddress对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost); // LAPTOP-RVFFB7FM/192.168.23.1
 
        // 2.根据机器的名字获取InetAddress对象
        InetAddress inetAddress = InetAddress.getByName("LAPTOP-RVFFB7FM");
        System.out.println(inetAddress);
 
        // 3.根据域名返回InetAddress对象，比如www.baidu.com
        InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress1);
 
        // 4.根据InetAddress对象，获取对应的ip地址
        String address = inetAddress1.getHostAddress();
        System.out.println(address);
 
        // 5.通过InetAddress对象，获取对应的主机名
        String hostName = inetAddress1.getHostName();
        System.out.println(hostName);
    }
}
三、Socket
1.套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准

2.通信的两端都要有Socket，是两台机器间通信的端点，网络通信其实就是Socket间的通信

3.Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输

4.一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

四、TCP网络编程
1.基于客户端一服务端的网络通信， 底层使用的是TCP/IP协议

2.应用场景举例: 客户端发送数据，服务端接受并显示控制台

3.基于Socket的TCP编程


（一）案例一——使用字节流
 

服务端

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        // 1.在9999端口监听，等待链接
        //  细节：要求该端口没有其他人监听
        ServerSocket serverSocket = new ServerSocket(9999);
 
        System.out.println("服务端，在9999端口监听，等待连接...");
        // 2.如果没有客户端连接9999端口，该方法会阻塞等待连接
        // 如果有连接，返回一个socket
        Socket socket = serverSocket.accept();
 
        System.out.println(socket.getClass());
        // 3.通过socket.getInputStream() 读取
        // 客户端写入到数据通道的数据，显示
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, readLen));
        }
        // 4.关闭流
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出...");
 
    }
}
客户端 

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        // 1.连接9999端口，连接成功返回一个socket
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        // 2.连接上后，生成socket，通过socket.getOutputStream()
        OutputStream outputStream = socket.getOutputStream();
        // 3.输出信息
        outputStream.write("hello, socket".getBytes());
        // 4.关闭流和连接，节省资源
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}
（二）案例二——使用字节流 


服务端

public class SocketTCP02Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
 
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }
 
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello Client".getBytes());
        // 设置结束标记
        socket.shutdownOutput();
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}
客户端 

public class SocketTCP02Client {
    public static void main(String[] args) throws Exception{
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello Server".getBytes());
        // 设置结束标记, socket.close()也做了同样的事情
        // 但是因为我们下面还有获取数据通道信息，因此不能关闭，只能shutdownOutput()
        socket.shutdownOutput();
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while((readLen = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLen));
        }
 
        outputStream.close();
        inputStream.close();
        socket.close();
    }
}
（三）案例三——使用字符流


服务端

public class SocketTCP03Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
 
        InputStream inputStream = socket.getInputStream();
        // IO读取，使用字符流输入，使用InputStreamReader将InputStream转化为字符流
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        String s = reader.readLine();
        System.out.println(s);
 
        // 字符流方式的输出
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
        writer.write("hello Client 字符流");
        writer.newLine(); // 插入一个换行符，代表写入的内容结束
        writer.flush(); // 字符流需要手动刷新，否则数据不会写入数据通道
 
        reader.close();
        writer.close();
        socket.close();
        serverSocket.close();
    }
}
客户端 

public class SocketTCP03Client {
    public static void main(String[] args) throws Exception{
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        // 通过输出流，转换为字符流
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
        writer.write("hello Server 字符流");
        writer.newLine(); // 插入一个换行符，代表写入的内容结束
        writer.flush(); // 字符流需要手动刷新，否则数据不会写入数据通道
 
 
        InputStream inputStream = socket.getInputStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        String s = reader.readLine();
        System.out.println(s);
 
        reader.close();
        writer.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}
（四）案例四——使用字符流


 StreamUtils

/**
 * 此类用于演示关于流的读写方法
 *
 */
public class StreamUtils {
    /**
     * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
     * @param is
     * @return
     * @throws Exception
     */
    public static byte[] streamToByteArray(InputStream is) throws Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
        byte[] b = new byte[1024];//字节数组
        int len;
        while((len=is.read(b))!=-1){//循环读取
            bos.write(b, 0, len);//把读取到的数据，写入bos    
        }
        byte[] array = bos.toByteArray();//然后将bos 转成字节数组
        bos.close();
        return array;
    }
    /**
     * 功能：将InputStream转换成String
     * @param is
     * @return
     * @throws Exception
     */
    
    public static String streamToString(InputStream is) throws Exception{
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder builder= new StringBuilder();
        String line;
        while((line=reader.readLine ())!=null){
            builder.append(line+"\r\n");
        }
        return builder.toString();
        
    }
 
}
服务端

public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8888);
        // 等待连接
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        String destFilePath = "src\\a.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
        // 向客户端回复“收到图片”
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();
        writer.close();
        bis.close();
        socket.close();
    }
}
客户端 

public class TCPFileUploadClient {
    public static void main(String[] args) throws  Exception{
        // 客户端连接服务端8888端口，得到socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        // 读取本地的文件转换为字节数组
        String filePath = "D:\\image\\a.jpg";
        FileInputStream fileInputStream = new FileInputStream(filePath);
        BufferedInputStream bis = new BufferedInputStream(fileInputStream);
        // 该字节数组就是文件
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        OutputStream outputStream = socket.getOutputStream();
//        outputStream.write(bytes);
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        bos.write(bytes);
        
        socket.shutdownOutput(); // 写入数据的结束标记
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String s = reader.readLine();
        System.out.println(s);
        reader.close();
        bos.close();
        bis.close();
        socket.close();
    }
}

五、UDP网络编程
（一）基本介绍
1.类 DatagramSocket 和 DatagramPacket[数据包/数据报]实现了基于 UDP协议网络程序。

2.UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

3.DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

4.UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

（二）基本流程
1.核心的两个类/对象 DatagramSocket与DatagramPacket

2.建立发送端，接收端(没有服务端和客户端概念)

3.发送数据前，建立数据包/报 DatagramPacket对象

4.调用DatagramSocket的发送、接收方法

5.关闭DatagramSocket

（三）案例


发送端

public class UDPSenderB {
    public static void main(String[] args) throws Exception{
        // 1.创建一个DatagramSocket，监听9998端口
        DatagramSocket socket = new DatagramSocket(9998);
        // 2.创建DatagramPacket，接收数据
        byte[] data = "你好，明天吃火锅".getBytes();
        DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9999);
        // 3.发送数据
        socket.send(packet);
 
        // 接收消息
        data = new byte[1024];
        packet = new DatagramPacket(data, data.length);
        socket.receive(packet);
        int length = packet.getLength();
        data = packet.getData();
        String msg = new String(data, 0, length);
        System.out.println(msg);
        // 4.关闭资源
        socket.close();
    }
}
接收端

public class UDPReceiverA {
    public static void main(String[] args) throws Exception{
        // 1.创建一个DatagramSocket对象，监听9999端口
        DatagramSocket socket = new DatagramSocket(9999);
        // 2.构建一个DatagramPacket，准备接受数据
        byte[] data = new byte[1024];
        DatagramPacket packet = new DatagramPacket(data, data.length);
        // 3.接收数据，如果没有数据则堵塞，接收到的数据存放在packet中
        System.out.println("接收端A等待接收数据...");
        socket.receive(packet);
        // 4.接收完数据转化为String并输出
        int length = packet.getLength();
        data = packet.getData();
        String msg = new String(data, 0, length);
        System.out.println(msg);
 
        // 回复消息
        data = "好的，明天见".getBytes();
        packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9998);
        socket.send(packet);
        // 5.关闭资源
        socket.close();
 
    }
}
六、案例
（一）案例一


服务端

public class HomeWork01Server {
    public static void main(String[] args) throws Exception{
        System.out.println("服务器等待接收消息...");
 
        DatagramSocket socket = new DatagramSocket(9999);
        byte[] data = new byte[1024];
        DatagramPacket packet = new DatagramPacket(data, data.length);
        socket.receive(packet);
 
        int length = packet.getLength();
        data = packet.getData();
        String msg = new String(data, 0, length);
        System.out.println(msg);
        String returnMsg = "";
        if("name".equals(msg)) {
            returnMsg = "我是nova";
        } else if("hobby".equals(msg)){
            returnMsg = "编写java程序";
        } else {
            returnMsg = "你说啥呢";
        }
        data = returnMsg.getBytes();
        packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9998);
        socket.send(packet);
 
        socket.close();
    }
}
客户端

public class HomeWork01Client {
    public static void main(String[] args) throws Exception{
        System.out.println("请输入您的消息:");
 
        Scanner sc = new Scanner(System.in);
        String msg = sc.next();
        DatagramSocket socket = new DatagramSocket(9998);
        byte[] data = msg.getBytes();
        DatagramPacket packet = new DatagramPacket(data, 0, data.length, InetAddress.getByName("192.168.23.1"), 9999);
        socket.send(packet);
 
        data = new byte[1024];
        packet = new DatagramPacket(data, data.length);
        socket.receive(packet);
        int length = packet.getLength();
        data = packet.getData();
        System.out.println(new String(data, 0, length));
 
    }
}
（二）案例二


服务端

public class HomeWork03Server {
    public static void main(String[] args) throws Exception{
        System.out.println("服务端监听9999端口，等待接收文件名...");
        // 1.创建一个socket对象
        ServerSocket serverSocket = new ServerSocket(9999);
        // 2.接收传递过来的文件名
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        // 这里使用了while循环，是考虑客户端可能发送的文件名较大的情况
        byte[] buf = new byte[1024];
        int len = 0;
        String downLoadFileName = "";
        while((len = inputStream.read(buf)) != -1) {
            downLoadFileName += new String(buf, 0, len);
        }
 
        System.out.println("客户端希望下载的文件名: " + downLoadFileName);
        // 3.确定文件名
        // 如果客户端要求下载高山流水，则获取文件流返回，否则，返回无名mp3
        String filePath = "";
        if("高山流水".equals(downLoadFileName)) {
            filePath = "src//高山流水.mp3";
        } else {
            filePath = "src//无名.mp3";
        }
        // 4.获取文件输入流并转化为字节数组
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        byte[] data = StreamUtils.streamToByteArray(bis);
        // 5.获取socket输出流并写出数据
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(data);
        socket.shutdownOutput();
        // 6.关闭资源
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
 
        System.out.println("服务端传输文件完毕，退出");
    }
}
客户端

public class HomeWork03Client {
    public static void main(String[] args) throws Exception{
        System.out.println("请输入下载的文件名：");
        // 1.获取用户输入的文件名
        Scanner sc = new Scanner(System.in);
        String fileName = sc.next();
        // 2.创建连接
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        // 3.获取socket关联的输出流并写出
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(fileName.getBytes());
        //   设置写入结束的标记
        socket.shutdownOutput();
        // 4.获取输入流并转化为字节数组
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] data = StreamUtils.streamToByteArray(bis);
 
        // 5.获取写出流，将文件写入磁盘
        String fileNamePath = "src//com//hspedu/homework//" + fileName + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileNamePath));
        bos.write(data);
 
        // 6.关闭资源
        outputStream.close();
        bos.close();
        bis.close();
        socket.close();
 
        System.out.println("文件下载完毕，退出");
 
    }

RiverStudy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java网络编程——TCP编程
weixin_52386948的博客
07-17 733
服务器端用ServerSocket监听指定端口；客户端使用Socket(InetAddress,port)连接服务器；服务器端用accept()接收连接并返回Socket实例；双方通过Socket打开InputStream/OutputStream读写数据；服务器端通常使用多线程同时处理多个客户端连接，利用线程池可大幅提升效率；flush()方法用于强制输出缓冲区到网络。https。...
第二十一章Java网络编程
你好, 我在学java的博客
12-22 1684
socket
Java网络编程基础：TCP Socket套接字编程 IntAddress UDP等...
最新发布
IH_LZH的博客
03-24 1048
在主机中，端口号1~1024是系统保留端口号，用来为常用的网络服务程序所占用。为了准确地定位网络上的目标主机，网络中的每个设备都会有一个唯一的数字标识，即网络设备的IP地址，通过ip地址，可以精确地匹配目标主机，是网络中资源共享、数据传输的依据。当客户端连接到服务端后，实际上客户端也是通过一个端口和服务器端进行通讯的，这个端口是TCP/IP来分配的，是不确定的，是随机的。Socket应用程序来说，需要与服务器端建立连接（通过ip和端口号确定主机上的程序），并向服务器端发送数据，接收服务器端数据；
Java之TCP编程
m0_59340907的博客
07-17 470
使用Java进行TCP编程时，需要使用Socket模型；服务器用ServerSocket监听指定接口；客户端使用Socket(InetAddress,port)连接服务器；服务器端用accept()接受连接并返回Socket实例；双方通过Socket打开InputStream/OutputStream读写数据；https。...
windows——socket通讯.zip
12-16
基于Windows的SOCKET编程，里面包含的UDP和TCP的代码实现，是现在网络通讯中的基本代码，编译环境是VS都可以。
如何实现socket网络编程的多线程
08-26
首先，学好计算机网络知识真的很重要。虽然，学不好不会影响理解下面这个关于宏观讲解，但是，学好了可以自己打渔吃，学不好就只能知道眼前有鱼吃却打...在Java中网络程序有2种协议：TCP和UDP,下面可以和小编一起学习下
计算机网络课程设计 多线程端口扫描器（TCP/UDP端口扫描）（java实现）带GUI界面
07-10
计算机网络课程设计——端口扫描器的实现 1．利用Socket通信机制实现一个多线程的端口扫描器。 2．设计要求： 2.1用户界面：用户可以输入IP地址或IP地址段；...2.3 采用Java网络编程包java.io中提供的编程接口实现。
基于JAVA CS远程监控系统软件的实现
05-18
——用Java Socket来实现。 2．用Java采集事件，封装成消息，用于发送。 ——在主控端机器上采集事件(一般只不过是键盘和鼠标的事件)，然后封装成消息类传输到被监控端。 3．在被监控端上重演主控端
Unity商业游戏底层加载框架一
weixin_43899724的博客
09-18 479
本模块主要讲解： AssetBundle打包管理； 类对象池和资源对象池； 离线数据及配置表； 使用框架制作简单的UI； 预备知识了解 程序集（可以自行网上查找了解）； unity资源加载方式（1，拖到组件上 2，Resources.load 3,AssetBundle 4,AssetDataBase.LoadAtPtah）； c#的xml序列化 1，类转成xml 2，以及转成二进制； unity asset序列化； xml序列化与反序列化例子 //要序列...
用JAVA进行TCP编程(原创)
10-12
用JAVA进行TCP编程(原创),网上绝对找不到雷同
Java socket字节流传输示例解析
09-01
主要为大家详细介绍了Java socket字节流传输示例,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java socket 传送字节流(前后台)
zhangzhikaixinya的专栏
04-25 1万+
因为考虑到数据传送的安全性.所以,用字节流进行socket的传输..例子如下: 客户端: //获得流 byteOut = new ByteArrayOutputStream(); out = new DataOutputStream(byteOut);      //转为字节流 byte[] messes=message.getBytes("GBK"); //获得长度 int l
socket中传输byte数组数据
chance_66的博客
02-06 1万+
socket中传输byte数组数据
Java TCP 编程
Zcp的博客
08-08 744
接上一篇的内容，下面是TCP编程的步骤： TCP分为客户端和服务端，其中： 客户端 创建Socket连接服务端(指定ip地址,端口号)通过ip地址找对应的服务器 调用Socket的getInputStream()和getOutputStream()方法获取和服务端相连的IO流 输入流可以读取服务端输出流写出的数据 输出流可以写出数据到服务端的输入流 服务端 创建ServerSoc...
Java 网络编程
热门推荐
ZaynFox的博客
05-30 6万+
网络编程 一、网络编程基础概念 首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的互相传递信息，共享硬件，软件，数据信息等资源。 计算机网络的主要功能： 资源共享 信息传输与集中处理 均衡负荷与分布处理 ...
java 基于tcp的socket编程
03-16
Java基于TCP的Socket编程是一种网络编程技术，它使用TCP协议来实现数据的传输和通信。通过Java Socket编程，可以实现客户端和服务器之间的数据传输和通信，实现网络应用程序的开发。Java Socket编程需要使用Java Socket类和ServerSocket类，其中Socket类用于创建客户端套接字，ServerSocket类用于创建服务器套接字。通过Socket类和ServerSocket类，可以实现数据的传输和通信，实现网络应用程序的开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值