java网络编程

最新推荐文章于 2025-07-02 16:47:19 发布
原创 最新推荐文章于 2025-07-02 16:47:19 发布 · 240 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

java 网络编程

一、概述

(一)、计算机网络

​ 把分布在不同地理区域的计算机胡专门的外部设备用通信线路互连城一个规模大、功能强的网络系统，从而使总多计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。

(二)、网络编程的目的

直接或间接地通过网络协议与其他计算机进行通讯 。

(三)、网络编程的主要两个问题

  1. 如何准确的定位网络上一台或多台主机。
  2. 找到主机后如何可靠高效地进行数据传输。

二、通讯要素

(一)、IP和port

1. Ip地址
  • 唯一的标识Internet上的计算机。
  • 本地回环地址(hostAddress): 127.0.0.1 主机名(hostName)、localhost。
2. 端口号

  • 标识正在计算机上运行的进程(程序)。

  • 不同的进程有不同的端口号。

  • 被规定为一个16位整数的0~65535, 0-1023被预先定义的服务铜线占用，所以我们要用的话就选择1024-65535之间的某一个端口尽心通信，以免端口冲突。

IP和端口号组合得到一个网络套接字。

(二)、网络通信协议

​ 计算机网络中实现通信必须要有一些约定，这就是通信协议，对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。

1. TCP/IP协议簇
  • 传输控制协议TCP
    • 使用TCP之前，必须建立TCP连接，形成传输数据通道。
    • 传输前，采用“三次握手‘方式，是可靠的。
    • TCP协议进行通信的两个应用进程：客户端、服务端。
    • 在连接中可进行大数据量的传输。
    • 传输完毕，必须释放已建立的连接，效率低。

  • 用户数据包协议UDP

    • 将数据、源、目的封装成数据包，不需要建立连接。
    • 每个数据包的大小限制在64K内。
    • 不需要连接，不可靠。

    • 发送数据结束时不需要释放资源，速度快。

      1. IP协议是网络层的主要协议，支持网间互连的数据通信。
      2. TCP/IP四层体系结构：物理链路层、IP层、传输层和应用层。

三、InetAddress类

1. InetAddress 类的方法

这个类表示互联网协议(IP)地址。下面列出了 Socket 编程时比较有用的方法：

序号方法描述
1static InetAddress getByAddress(byte[] addr) 在给定原始 IP 地址的情况下，返回 InetAddress 对象。
2static InetAddress getByAddress(String host, byte[] addr) 根据提供的主机名和 IP 地址创建 InetAddress。
3static InetAddress getByName(String host) 在给定主机名的情况下确定主机的 IP 地址。
4String getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
5String getHostName() 获取此 IP 地址的主机名。
6static InetAddress getLocalHost() 返回本地主机。
7String toString() 将此 IP 地址转换为 String。

2. InetAddress类的创建和使用

  1. 创建 

    package lj.socket;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
* Class InetAddressTest ...
* @author LiJun
* Created on 2018/8/10
* InetAddress：位于java.net包下
* 1.InetAddress用来代表IP地址，一个InetAddress对象就代表着一个IP地址
* 2.创建InetAddress对象:getName(String host)
* 3. getHostName() getHostAddress
*/
public class InetAddressTest {
   public static void main(String[] args) throws UnknownHostException {
       // 获取的时候先先找本地的hosts，是否有输入的域名地址，没有的话，通过DNS服务器，找到主机
       // 本地hosts文件目录 C:\Windows\System32\drivers\etc\hosts
       InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
       // 结果为：www.baidu.com
       System.out.println(inetAddress.getHostName());
       // 结果为：180.97.33.107
       System.out.println(inetAddress.getHostAddress());

       // 获取本地主机
       InetAddress inetAddress1 = InetAddress.getLocalHost();
       System.out.println(inetAddress1.getHostName());
       System.out.println(inetAddress1.getHostAddress());
   }
}
  2. 2.

四、TCP-UDP

(一)、Socket

  • 利用套接字(socket)开发应用程序，是当前的标准了。
  • 通信的两端都要有Socket，是两台机器间通信的端点。
  • 网络通信其实就是Socket间的通信。
  • Socket允许程序把网络连接当成一个流，数据在两个Socket间通过I/O传输。
  • 一般主动发起通讯的应用程序属客户端，等待通信请求的属服务端。
1.ServerSocket 类的方法

服务器应用程序通过使用 java.net.ServerSocket 类以获取一个端口,并且侦听客户端请求。

ServerSocket 类有四个构造方法：

序号方法描述
1public ServerSocket(int port) throws IOException 创建绑定到特定端口的服务器套接字。
2public ServerSocket(int port, int backlog) throws IOException 利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
3public ServerSocket(int port, int backlog, InetAddress address) throws IOException 使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
4public ServerSocket() throws IOException 创建非绑定服务器套接字。
5public int getLocalPort() 返回此套接字在其上侦听的端口。
6public Socket accept() throws IOException 侦听并接受到此套接字的连接。
7public void setSoTimeout(int timeout) 通过指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位。
8public void bind(SocketAddress host, int backlog) 将 ServerSocket 绑定到特定地址（IP 地址和端口号）。
2.Socket 类的方法

java.net.Socket 类代表客户端和服务器都用来互相沟通的套接字。客户端要获取一个 Socket 对象通过实例化 ，而 服务器获得一个 Socket 对象则通过 accept() 方法的返回值。

Socket 类有五个构造方法.

序号方法描述
1public Socket(String host, int port) throws UnknownHostException, IOException. 创建一个流套接字并将其连接到指定主机上的指定端口号。
2public Socket(InetAddress host, int port) throws IOException 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
3public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. 创建一个套接字并将其连接到指定远程主机上的指定远程端口。
4public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. 创建一个套接字并将其连接到指定远程地址上的指定远程端口。
5public Socket() 通过系统默认类型的 SocketImpl 创建未连接套接字
6public void connect(SocketAddress host, int timeout) throws IOException 将此套接字连接到服务器，并指定一个超时值。
7public InetAddress getInetAddress() 返回套接字连接的地址。
8public int getPort() 返回此套接字连接到的远程端口。
9public int getLocalPort() 返回此套接字绑定到的本地端口。
10public SocketAddress getRemoteSocketAddress() 返回此套接字连接的端点的地址，如果未连接则返回 null。
11public InputStream getInputStream() throws IOException 返回此套接字的输入流。
12public OutputStream getOutputStream() throws IOException 返回此套接字的输出流。
13public void close() throws IOException 关闭此套接字。

(二)、TCP-Socket

  1. 实现内容客户端给服务端发送消息，服务端接收并显示出来

    package lj.socket;

import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
* Class TCPTest1 ...
* 实现内容客户端给服务端发送消息，服务端接收并显示出来
*
* @author LiJun
* Created on 2018/8/10
*/
public class TCPTest1 {

   /**
    * 客户端
    */
   @Test
   public void client() {
       Socket socket = null;
       OutputStream outputStream = null;
       try {
           // 创建一个Socket的对象，通过构造器指明服务端的Ip地址，以及其接收程序的端口号
           socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
           // getOutputStream() 发送数据
           outputStream = socket.getOutputStream();
           // 具体的输出过程
           outputStream.write("我是客户端".getBytes());
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           // 关闭响应的流和socket
           if (outputStream != null) {
               try {
                   outputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

   /**
    * 服务端
    */
   @Test
   public void server() {
       ServerSocket serverSocket = null;
       Socket socket = null;
       InputStream inputStream = null;
       try {
           // 创建一个ServerSocket的对象，通过构造器指明自身的端口号
           serverSocket = new ServerSocket(9090);
           // 调用accept方法，返回一个Socket对象
           socket = serverSocket.accept();
           // 调用Socket的getInputStream方法获取从服务端发送过来的输入流
           inputStream = socket.getInputStream();
           // 处理获取到的数据
           byte[] bytes = new byte[20];
           int len = 0;
           while ((len = inputStream.read(bytes)) != -1) {
               String string = new String(bytes, 0, len);
               System.out.println(string);
           }
       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           // 关闭相应的流和Socket、ServerSock而对象
           if (inputStream != null) {
               try {
                   inputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (serverSocket != null) {
               try {
                   serverSocket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }

   }
}

  2. 实现客户端给服务端发送消息，服务端接收并显示出来并反馈信息

    package lj.socket;

import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
* Class TCPTest2 ...
* 实现客户端给服务端发送消息，服务端接收并显示出来并反馈信息
*
* @author LiJun
* Created on 2018/8/10
*/
public class TCPTest2 {

   /**
    * 客户端
    */
   @Test
   public void client() {
       Socket socket = null;
       OutputStream outputStream = null;
       InputStream inputStream = null;
       try {
           // 创建一个Socket的对象，通过构造器指明服务端的Ip地址，以及其接收程序的端口号
           socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
           // getOutputStream() 发送数据
           outputStream = socket.getOutputStream();
           // 具体的输出过程
           outputStream.write("我是客户端".getBytes());
/**********************************************************/
           socket.shutdownOutput();
/**********************************************************/
           inputStream = socket.getInputStream();
           byte[] bytes = new byte[20];
           int len = 0;
           while ((len = inputStream.read(bytes)) != -1) {
               String string = new String(bytes, 0, len);
               System.out.println(string);
           }

       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           // 关闭响应的流和socket
           if (inputStream != null) {
               try {
                   inputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (outputStream != null) {
               try {
                   outputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

   /**
    * 服务端
    */
   @Test
   public void server() {
       ServerSocket serverSocket = null;
       Socket socket = null;
       InputStream inputStream = null;
       OutputStream outputStream = null;
       try {
           // 创建一个ServerSocket的对象，通过构造器指明自身的端口号
           serverSocket = new ServerSocket(9090);
           // 调用accept方法，返回一个Socket对象
           socket = serverSocket.accept();
           // 调用Socket的getInputStream方法获取从服务端发送过来的输入流
           inputStream = socket.getInputStream();
           // 处理获取到的数据
           byte[] bytes = new byte[20];
           int len = 0;
           while ((len = inputStream.read(bytes)) != -1) {
               String string = new String(bytes, 0, len);
               System.out.println(string);
           }
           outputStream = socket.getOutputStream();
           outputStream.write("我已经收到了".getBytes());

       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           // 关闭相应的流和Socket、ServerSock而对象
           if (outputStream != null) {
               try {
                   outputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (inputStream != null) {
               try {
                   inputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (serverSocket != null) {
               try {
                   serverSocket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }

   }
}

    重点在于客户端发送了消息后的 socket.shutdownOutput();

  3. 从客户端发送文件给服务端，服务端保存包本地，反馈消息给客户端。

    package lj.socket;

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
* Class TCPTest3 ...
*
* @author LiJun
* Created on 2018/8/10
*/
public class TCPTest3 {

   /**
    * 客户端
    */
   @Test
   public void client() {
       Socket socket = null;
       OutputStream outputStream = null;
       FileInputStream fileInputStream = null;
       InputStream inputStream = null;
       try {
           socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
           outputStream = socket.getOutputStream();
           fileInputStream = new FileInputStream(new File("D://1.txt"));
           byte[] bytes = new byte[1024];
           int len = 0;
           while ((len = fileInputStream.read(bytes)) != -1) {
               outputStream.write(bytes, 0, len);
           }
           // 表明客户端发送成功
           socket.shutdownOutput();

           inputStream = socket.getInputStream();
           len = 0;
           while ((len = inputStream.read(bytes)) != -1) {
               String string = new String(bytes, 0, len);
               System.out.println(string);
           }

       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           // 关闭响应的流和socket
           if (inputStream != null) {
               try {
                   inputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (fileInputStream != null) {
               try {
                   fileInputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (outputStream != null) {
               try {
                   outputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

   /**
    * 服务端
    */
   @Test
   public void server() {
       ServerSocket serverSocket = null;
       Socket socket = null;
       InputStream inputStream = null;
       FileOutputStream fileOutputStream = null;
       OutputStream outputStream = null;
       try {
           serverSocket = new ServerSocket(9090);
           socket = serverSocket.accept();
           inputStream = socket.getInputStream();
           fileOutputStream = new FileOutputStream(new File("D://2.txt"));
           byte[] bytes = new byte[1024];
           int len = 0;
           while ((len = inputStream.read(bytes)) != -1) {
               fileOutputStream.write(bytes, 0, len);
           }
           outputStream = socket.getOutputStream();
           outputStream.write("我已经成功接收".getBytes());

       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           // 关闭相应的流和Socket、ServerSock而对象
           if (outputStream != null) {
               try {
                   outputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (fileOutputStream != null) {
               {
                   try {
                       fileOutputStream.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
           if (inputStream != null) {
               try {
                   inputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           if (serverSocket != null) {
               try {
                   serverSocket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }

   }
}

(三)、UDP

  • 类DatagramSocket和 DatagramPacket实现UDP协议。
  • UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报一定能安全传输，也不能确定什么时候能传输成功。
  • DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
  • UDP协议中每个数据报都给出了完整的地址信息，无须建立发送方和接收方的连接。
package lj.socket;

import org.junit.Test;

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

/**
 * Class UDPTest ...
 *
 * @author LiJun
 * Created on 2018/8/10
 */
public class UDPTest {
    /**
     * 发送端
     */
    @Test
    public void send() {

        DatagramSocket datagramSocket = null;
        try {
            datagramSocket = new DatagramSocket();

            byte[] bytes = "hello world".getBytes();
            DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length,
                    InetAddress.getByName("127.0.0.1"), 9090);

            datagramSocket.send(datagramPacket);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (datagramSocket != null) {
                datagramSocket.close();
            }
        }


    }

    /**
     * 接收端
     */
    @Test
    public void receive() {
        DatagramSocket datagramSocket = null;
        try {
            datagramSocket = new DatagramSocket(9090);
            byte[] bytes = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
            datagramSocket.receive(datagramPacket);

            String string = new String(datagramPacket.getData(), 0, datagramPacket.getLength());
            System.out.println(string);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (datagramSocket != null) {
                datagramSocket.close();
            }
        }
    }
}

五、URL编程

  • URL

    统一资源定位符，他表示Internet上某一资源的地址。通过URL我们可以访问Internet上的各种网络资源，比如常见的www、ftp站点。浏览器通过解析给定的URL可以在网络上查找相应的文件或其他资源。

  • URL的j基本结构(5部分)

    <传输协议>://<主机名>:<端口号>/<文件名>

    eg:http://39.106.200.103:8080/test/index.html

package lj.socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

/**
 * Class URLTest ...
 *
 * @author LiJun
 * Created on 2018/8/10
 */
public class URLTest {

    public static void main(String[] args) {
        // 1.创建一个URL对象
        URL url = null;
        URLConnection urlConnection = null;
        InputStream inputStream = null;
        try {
            url = new URL("https://dzs.qisuu.la/txt/31268.txt");
            urlConnection = url.openConnection();

            // 获取该URL的协议名
            System.out.println(url.getProtocol());
            // 获取该URL的主机名
            System.out.println(url.getHost());
            // 获取该URL的端口号
            System.out.println(url.getPort());
            // 获取该URL的文件路径
            System.out.println(url.getPath());
            // 获取该URL的文件名
            System.out.println(url.getFile());
            // 获取该URL在文件中的相对位置
            System.out.println(url.getRef());
            // 获取该URL的查询名
            System.out.println(url.getQuery());


            // 如何将服务端的文件保存下来

            // 处理读取中文的时候可能要乱码的问题 utf-8和gbk都试试
            inputStream = urlConnection.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String string;
            while ((string = br.readLine()) != null) {
                System.out.println(string);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
JAVA 网络编程
ashfiqa的博客
01-01 7506
计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。网络通信协议是网络编程中的关键，通信双方达成的一种共识，当通信双方都遵守这样的约定，才能正确传输信息。
day16-网络编程
weixin_48048140的博客
07-26 298
1.网络编程入门 1.1 网络编程概述【理解】 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程 在网络通信协议下，不同计算机上运行的程序，可以进行数据传输 1.2 网络编程三要素【理解】 IP地址 要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。
网络编程（Java）
小楊同學
03-04 567
计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
网络编程(java)
m0_58450531的博客
07-15 1385
1.1什么是计算机网络？把分布在不同地理区域的，居有独立功能的计算机，通过通信线路连接起来，能够实现资源传递共享。有人说，20世纪最伟大的发明不是计算机，而是计算机网络。还有人说，如果你买了计算机而没有联网，就等于买了电话机而没有接电话线一样。什么是网络编程？使用计算机语言开发软件，让软件能够通过网络进行数据交换，java语言支持网络通信。Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。程序员面对的是一个统一的网络编程环境。......
JAVA.网络编程
gzj77的博客
07-07 294
Java 网络编程网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。java.net包中J2SE的API包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。java.net包中提供了两种常见的网络协议的支持： TCP： TCP是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称TC
精选资源
Java网络编程案例教程习题参考答案 .pdf
12-28
Java网络编程案例教程习题参考答案 Java_network_programming是Java编程语言中一个基础组件，用于实现网络通信。以下是Java网络编程案例教程习题参考答案中涉及到的知识点： 1. Socket编程：Socket是Java网络编程...
精选资源
Java网络编程期末考试复习题库+答案
07-06
Java网络编程是计算机科学中的一个重要领域，特别是在软件开发中，它涉及到如何通过网络进行数据传输和通信。在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这...
Java网络编程实验报告.pdf
09-26
"Java网络编程实验报告" 本实验报告主要介绍了Java网络编程的基本概念和实现方法，通过设计和实现一个简单的客户端/服务器应用程序，了解Java网络编程的基本原理和实现方法。 知识点1：Java 网络编程基础 Java ...
JAVA（网络编程）
2401_82568471的博客
05-29 732
TCP（传输控制协议）：面向连接的协议，提供可靠的数据传输服务，保证数据的顺序和完整性，但效率相对较低。适用于对可靠性要求较高的场景，如文件传输、邮件等。端口号用于标识设备上的应用程序，范围是 0 - 65535，其中 0 - 1023 是系统保留端口，1024 - 65535 是用户可用端口。ServerSocket 类：用于实现 TCP 服务器端，负责监听客户端的连接请求，并创建 Socket 对象与客户端通信。Socket 类：用于实现 TCP 客户端，负责建立与服务器的连接，并进行数据传输。
Java 网络编程
lucien_ma的博客
08-07 373
网络编程 本文章文个人“Java零基础实战”学习笔记，侵权删 所谓的 Web 编程就是编写程序运行在同一网络下的两个终端上，使得他们之间可以进行数据传输。在正式学习 Java Web 编程之前，我么先来了解网络的相关基础知识。 ​ 计算机网络就是通过硬件设施、传输媒介把各个不同的物理地址上的计算机进行连接，形成一个资源共享和数据传输的网络系统。两台终端通过网络进行连接时，需要遵守一定的规则，这个规则就是网络协议（network rotocol），网络协议主要由 3 个特征组成。 语法：数据信息的结果。 语
Java—网络编程总结（整理版）
Swordfall的博客
05-05 335
1.概述 　　计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。 2.网络分层 　　计算机网络20世纪60年代出现，经历了20世纪70年代、80年代和90年...
JAVA网络编程
sout
04-25 281
一、网络编程概述通讯要素1：IP 和 端口号1）IP 地址：InetAddress唯一的标识 Internet 上的计算机本地回环地址(hostAddress)：127.0.0.1      主机名(hostName)：localhost不易记忆2）端口号标识正在计算机上运行的进程（程序）不同的进程有不同的端口号被规定为一个 16 位的整数 0~65535。其中，0~1023被预先定义的服务通信占...
Java 网络编程基础
2301_79083000的博客
10-05 1860
包入门Java网络的
网络编程java版
m0_52540692的博客
05-28 177
文章目录网络编程一.网络编程概述1.概述2.OSI参考模型3.网络通信的三要素：二、IP以及端口号三、TCP协议1.服务端2.客户端四、UDP协议1.服务端2.客户端 网络编程 一.网络编程概述 1.概述 Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序 Java提供的网络类库，可以实现网络连接，联网的底层细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网
JAVA中的网络编程
最新发布
2301_81831660的博客
07-02 1029
传输层会对那个数据进行解析，去掉 TCP 报头，取出里面的 TCP 数据报交给应用层；主机A的发送速度不光取决于主机B的处理能力，也取决于中间链路的处理能力，主机A向主机B发送的过程中有许多中间节点，拥塞控制的处理方式就是通过 “实验” 的方式，逐渐调整发送速度，主机A开始的时候以一个较小的窗口来发送数据，如果数据很流畅的到达了，就逐渐增加窗口大小，如果加大到一定程度后开始出现丢包（通信链路出现拥堵），那么就减小窗口，通过这样的调整过程逐渐找到一个合适的范围，拥塞窗口就在这个范围中不断变化，达到动态平衡。
Java|网络编程
weixin_42054526的博客
08-02 555
Java|网络编程1.网络编程概述2.网络编程三要素3.网络编程三要素之IP3.1 IP概述3.2 IP地址的组成3.3 IP地址分类3.4 InetAddress类4.网络编程三要素之端口5.网络编程三要素之协议6.Socket套接字7.使用UDP协议进行通信7.1 UDP协议使用到的类7.2 几个案例7.2.1 简单的UDP协议发送与接收数据7.2.2 UDP协议发送端的数据来自于键盘录入7....
Java网络编程入门源码示例
根据所提供的文件信息——标题为“java网络编程 源代码”，描述指出这是孙卫琴的作品，并强调其对网络编程入门具有显著帮助，标签包括“java网络编程 源代码 java源代码 网络编程”，以及压缩包内包含名为“Java网络...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值