Java从入门到精通十三(java网络编程)【下】

简介: Socket(客户端套接字)public class Socketextends Object此类实现客户端套接字(也可以就叫“套接字”)。套接字是两台机器间通信的端点。套接字的实际工作由 SocketImpl 类的实例执行。应用程序通过更改创建套接字实现的套接字工厂可以配置它自身,以创建适合本地防火墙的套接字。提供的构造方法

Socket(客户端套接字)

public class Socketextends Object


此类实现客户端套接字(也可以就叫“套接字”)。套接字是两台机器间通信的端点。

套接字的实际工作由 SocketImpl 类的实例执行。应用程序通过更改创建套接字实现的套接字工厂可以配置它自身,以创建适合本地防火墙的套接字。


提供的构造方法


Socket()

通过系统默认类型的 SocketImpl 创建未连接套接字

Socket(InetAddress address, int port)

创建一个流套接字并将其连接到指定 IP 地址的指定端口号。

Socket(InetAddress host, int port, boolean stream)

已过时。 Use DatagramSocket instead for UDP transport.

Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

创建一个套接字并将其连接到指定远程地址上的指定远程端口。

Socket(Proxy proxy)

创建一个未连接的套接字并指定代理类型(如果有),该代理不管其他设置如何都应被使用。

protected Socket(SocketImpl impl)

使用用户指定的 SocketImpl 创建一个未连接 Socket。

Socket(String host, int port)

创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket(String host, int port, boolean stream)

已过时。 使用 DatagramSocket 取代 UDP 传输。

Socket(String host, int port, InetAddress localAddr, int localPort)

创建一个套接字并将其连接到指定远程主机上的指定远程端口


提供的api接口


void bind(SocketAddress bindpoint)

将套接字绑定到本地地址。

void close()

关闭此套接字。

void connect(SocketAddress endpoint)

将此套接字连接到服务器。

void connect(SocketAddress endpoint, int timeout)

将此套接字连接到服务器,并指定一个超时值。

SocketChannel getChannel()

返回与此数据报套接字关联的唯一 SocketChannel 对象(如果有)。

InetAddress getInetAddress()

返回套接字连接的地址。

InputStream getInputStream()

返回此套接字的输入流。

boolean getKeepAlive()

测试是否启用 SO_KEEPALIVE。

InetAddress getLocalAddress()

获取套接字绑定的本地地址。

int getLocalPort()

返回此套接字绑定到的本地端口。

SocketAddress getLocalSocketAddress()

返回此套接字绑定的端点的地址,如果尚未绑定则返回 null。

boolean getOOBInline()

测试是否启用 OOBINLINE。

OutputStream getOutputStream()

返回此套接字的输出流。

int getPort()

返回此套接字连接到的远程端口。

int getReceiveBufferSize()

获取此 Socket 的 SO_RCVBUF 选项的值,该值是平台在 Socket 上输入时使用的缓冲区大小。

SocketAddress getRemoteSocketAddress()

返回此套接字连接的端点的地址,如果未连接则返回 null。

boolean getReuseAddress()

测试是否启用 SO_REUSEADDR。

int getSendBufferSize()

获取此 Socket 的 SO_SNDBUF 选项的值,该值是平台在 Socket 上输出时使用的缓冲区大小。

int getSoLinger()

返回 SO_LINGER 的设置。

int getSoTimeout()

返回 SO_TIMEOUT 的设置。

boolean getTcpNoDelay()

测试是否启用 TCP_NODELAY。

int getTrafficClass()

为从此 Socket 上发送的包获取 IP 头中的流量类别或服务类型。

boolean isBound()

返回套接字的绑定状态。

boolean isClosed()

返回套接字的关闭状态。

boolean isConnected()

返回套接字的连接状态。

boolean isInputShutdown()

返回是否关闭套接字连接的半读状态 (read-half)。

boolean isOutputShutdown()

返回是否关闭套接字连接的半写状态 (write-half)。

void sendUrgentData(int data)

在套接字上发送一个紧急数据字节。

void setKeepAlive(boolean on)

启用/禁用 SO_KEEPALIVE。

void setOOBInline(boolean on)

启用/禁用 OOBINLINE(TCP 紧急数据的接收者) 默认情况下,此选项是禁用的,即在套接字上接收的 TCP 紧急数据被静默丢弃。

void setPerformancePreferences(int connectionTime, int latency, int bandwidth)

设置此套接字的性能偏好。

void setReceiveBufferSize(int size)

将此 Socket 的 SO_RCVBUF 选项设置为指定的值。

void setReuseAddress(boolean on)

启用/禁用 SO_REUSEADDR 套接字选项。

void setSendBufferSize(int size)

将此 Socket 的 SO_SNDBUF 选项设置为指定的值。

static void setSocketImplFactory(SocketImplFactory fac)

为应用程序设置客户端套接字实现工厂。

void setSoLinger(boolean on, int linger)

启用/禁用具有指定逗留时间(以秒为单位)的 SO_LINGER。

void setSoTimeout(int timeout)

启用/禁用带有指定超时值的 SO_TIMEOUT,以毫秒为单位。

void setTcpNoDelay(boolean on)

启用/禁用 TCP_NODELAY(启用/禁用 Nagle 算法)。

void setTrafficClass(int tc)

为从此 Socket 上发送的包在 IP 头中设置流量类别 (traffic class) 或服务类型八位组 (type-of-service octet)。

void shutdownInput()

此套接字的输入流置于“流的末尾”。

void shutdownOutput()

禁用此套接字的输出流。

String toString()

将此套接字转换为 String


ServerSocket(服务器套接字)

public class ServerSocketextends Object


此类实现服务器套接字。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作,然后可能向请求者返回结果。

服务器套接字的实际工作由 SocketImpl 类的实例执行。应用程序可以更改创建套接字实现的套接字工厂来配置它自身,从而创建适合本地防火墙的套接字。


构造方法


ServerSocket()

创建非绑定服务器套接字。

ServerSocket(int port)

创建绑定到特定端口的服务器套接字。

ServerSocket(int port, int backlog)

利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。

ServerSocket(int port, int backlog, InetAddress bindAddr)

使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。


主要的api方法


Socket accept()

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

void bind(SocketAddress endpoint)

将 ServerSocket 绑定到特定地址(IP 地址和端口号)。

void bind(SocketAddress endpoint, int backlog)

将 ServerSocket 绑定到特定地址(IP 地址和端口号)。

void close()

关闭此套接字。

ServerSocketChannel getChannel()

返回与此套接字关联的唯一 ServerSocketChannel 对象(如果有)。

InetAddress getInetAddress()

返回此服务器套接字的本地地址。

int getLocalPort()

返回此套接字在其上侦听的端口。

SocketAddress getLocalSocketAddress()

返回此套接字绑定的端点的地址,如果尚未绑定则返回 null。

int getReceiveBufferSize()

获取此 ServerSocket 的 SO_RCVBUF 选项的值,该值是将用于从此 ServerSocket 接受的套接字的建议缓冲区大小。

boolean getReuseAddress()

测试是否启用 SO_REUSEADDR。

int getSoTimeout()

获取 SO_TIMEOUT 的设置。

protected void implAccept(Socket s)

ServerSocket 的子类使用此方法重写 accept() 以返回它们自己的套接字子类。

boolean isBound()

返回 ServerSocket 的绑定状态。

boolean isClosed()

返回 ServerSocket 的关闭状态。

void setPerformancePreferences(int connectionTime, int latency, int bandwidth)

设置此 ServerSocket 的性能首选项。

void setReceiveBufferSize(int size)

为从此 ServerSocket 接受的套接字的 SO_RCVBUF 选项设置默认建议值。

void setReuseAddress(boolean on)

启用/禁用 SO_REUSEADDR 套接字选项。

static void setSocketFactory(SocketImplFactory fac)

为应用程序设置服务器套接字实现工厂。

void setSoTimeout(int timeout)

通过指定超时值启用/禁用 SO_TIMEOUT,以毫秒为单位。

String toString()

作为 String 返回此套接字的实现地址和实现端口。


tcp通信



tcp发送数据



相比udp通信,tcp的发送端一定要根据客户端做出反应。否则,会报错。一般会报拒绝连接的异常。但是你可能会以为是端口的错误,其实可能并不是,是由于没有理解到tcp通信的特性导致。


package internet;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Tcp_demo {
    public static void main(String[] args) throws IOException {
        //创建客户端的socket对象
        Socket socket = new Socket("192.168.1.1",10000);
        //获取输出出流,写数据
        OutputStream os = socket.getOutputStream();
        os.write("hello,tcp我来了".getBytes());
        socket.close();
        os.close();
    }
}


但是你直接运行这个发送端是绝对会报错的,因为接收端没有,根本不会有什么反应,但是在udp就没什么问题,udp是不需要进行什么反馈,直接进行数据传输就可以。


如果你要对本机进行测试,完全没必要去那样直接指ip口。用方法获取ip地址就可以。


Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(),10000);


用到的一个流是输出流


OutputStream getOutputStream()

返回此套接字的输出流。


tcp接收数据



package internet;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo1 {
    public static void main(String[] args) throws IOException {
      //绑定到特定端口的服务器
        ServerSocket ss = new ServerSocket(10000);
        //倾听并接受到此套接字的连接
        Socket s = ss.accept();
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("数据是"+data);
//        s.close();
//        ss.close();
    }
}


tcp数据通信

发送接收数据(初步)

就是将上面的客户端和服务器端的程序接起来。


客户端


package internet;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Tcp_demo {
    public static void main(String[] args) throws IOException {
        //创建客户端的socket对象
        Socket socket = new Socket(InetAddress.getLocalHost().getHostAddress(),10000);
        //获取输出出流,写数据
        OutputStream os = socket.getOutputStream();
        os.write("hello,tcp我来了".getBytes());
        socket.close();
        os.close();
    }
}


服务器端


package internet;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo1 {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);
        Socket s = ss.accept();
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("数据是"+data);
//        s.close();
//        ss.close();
    }
}


这个进行通讯的话,首先我们需要开启一个服务器端的程序,然后运行客户端。



发送接收数据(信息反馈)

首先客户端的程序


package internet;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Tcp_demo2 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //获取输出流
        OutputStream os = s.getOutputStream();
        os.write("Hello,tcp".getBytes());
        //接收服务器反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端收到反馈:"+data);
        //释放资源
//        s.close();
    }
}


服务器端的


package internet;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo2_sever {
    public static void main(String[] args) throws IOException {
        //创建服务器端Socket
        ServerSocket ss = new ServerSocket(10086);
        Socket s = ss.accept();
        //获取输入流
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("服务器收到:" +data);
        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("收到数据".getBytes());
        ss.close();
    }
}



发送接收数据(键盘录入数据)

客户端


package internet;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Tcp_demo3 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //实现键盘录入(自己包装的键盘录入)
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while((line= br.readLine())!=null)
        {
            if("886".equals(line))
            {
                break;
            }
            //获取输出流对象
//            OutputStream os = s.getOutputStream();
//            os.write(line.getBytes());
            //一次写字符串
            //封装一下字节流对象
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bw.write(line);
            bw.newLine();
            bw.flush();
            s.close();
        }
    }
}


服务器端


package internet;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo3_server {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端连接返回对应socket对象
        Socket s = ss.accept();
        //获取输入流
        InputStream is = s.getInputStream();
        //字符输入流
        InputStreamReader isr = new InputStreamReader(is);
        //加入缓冲
        BufferedReader br = new BufferedReader(isr);
        String line;
        while ((line=br.readLine())!=null)
        {
            System.out.println(line);
        }
        //释放资源
        ss.close();
    }
}


需要注意的是,建立通讯的前提是两端都启动,如果一方关闭,就无法正常通讯。


发送接收数据(将收到的数据写入文本)

这样主要还是为了复习一下前面学到的io流

客户端


package internet;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Tcp_demo4 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //封装输出对象(数据来源于键盘录入)
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while((line=br.readLine())!=null)
        {
            if("886".equals(line))
            {
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        s.close();
    }
}


服务端


package internet;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo_server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端连接,返回一个对应的Socket对象
        Socket s = ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("666.txt"));
        String line;
        while((line= br.readLine())!=null)
        {
                bw.write(line);
                bw.newLine();
                bw.flush();
        }
        //释放资源
        bw.close();
        ss.close();
    }
}


发送接收数据(文件上传)

具体的是,我们客户端提供的数据来源于文件,然后结合流将文件内容读取,并写入,传到服务器端。(服务器将收到的数据写入文件,如此实现一个上传文件的效果。)


客户端代码


package internet;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class Tcp_demo5 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //数据来源文本文件
        BufferedReader br = new BufferedReader(new FileReader("E:\\java_doc\\src\\io_demo\\Student01.txt"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        br.close();
        s.close();
    }
}


服务器端代码


package internet;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo5_Server {
    public static void main(String[] args) throws IOException {
        //创建服务端
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端连接,返回一个对应的Socket对象
        Socket s = ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //将数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java_doc\\src\\io_demo\\data.txt"));
        String line;
        while((line= br.readLine())!=null)
        {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        ss.close();
    }
}


发送接收数据(文件上传和反馈)

基于上次代码的更改


客户端


package internet;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class Tcp_demo5 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //数据来源文本文件
        BufferedReader br = new BufferedReader(new FileReader("E:\\java_doc\\src\\io_demo\\Student01.txt"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //自定义结束标记
//        bw.write("886");
//        bw.newLine();
//        bw.flush();
        s.shutdownOutput();
        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine();
        System.out.println("服务器反馈:"+data);
        br.close();
        s.close();
    }
}


服务器端


package internet;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo5_Server {
    public static void main(String[] args) throws IOException {
        //创建服务端
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端连接,返回一个对应的Socket对象
        Socket s = ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //将数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java_doc\\src\\io_demo\\data.txt"));
        String line;
        while((line= br.readLine())!=null)
        {
//            if("886".equals(line))
//            {
//                break;
//            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("收到文件");
        bwServer.newLine();
        bwServer.flush();
        bw.close();
        ss.close();
    }
}


这里面有一个主要用到的方法


shutdownOutput

public void shutdownOutput()

throws IOException禁用此套接字的输出流。对于 TCP 套接字,任何以前写入的数据都将被发送,并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流,则该流将抛出 IOException


原因是如果不这样用的话


服务器会一直等待客户端的输出。既然服务器阻塞了,客户端等待着服务器的输出,也会被阻塞,所以导致客户端和服务端都被阻塞。


这样就得不到想要的结果。


调用Socket.shutdownOutput()方法后,客户端输出的数据都将被发送,并加上 TCP 的正常连接终止序列


发送接收数据(多线程实现)

虽然代码不多,但是还是有好多细节。


客户端不变


package internet;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class Tcp_demo5 {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(), 10086);
        //数据来源文本文件
        BufferedReader br = new BufferedReader(new FileReader("E:\\java_doc\\src\\io_demo\\Student01.txt"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //自定义结束标记
//        bw.write("886");
//        bw.newLine();
//        bw.flush();
        s.shutdownOutput();
        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine();
        System.out.println("服务器反馈:"+data);
        br.close();
        s.close();
    }
}


服务器端


package io_demo;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Tcp_demo5_Server_new {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10086);
        //监听客户端连接
        while(true)
        {
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }
    }
}


线程类


package io_demo;
import java.io.*;
import java.net.Socket;
public class ServerThread implements Runnable {
    private Socket s;
    public ServerThread(Socket s) {
            this.s = s;
    }
    @Override
    public void run() {
        //接收数据写入文本文件
        try {
            //解决名称冲突
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            int count = 0;
            File file = new File("E:\\java_doc\\src\\io_demo\\data+["+count+"].txt");
            while (file.exists())
            {
                count++;
                file = new File("E:\\java_doc\\src\\io_demo\\data+["+count+"].txt");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            String line;
            while((line=br.readLine())!=null)
            {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
            //反馈
            BufferedWriter bwServer = new BufferedWriter(new BufferedWriter(new OutputStreamWriter(s.getOutputStream())));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


目录
打赏
0
0
0
0
0
分享
相关文章
单位网络监控软件:Java 技术驱动的高效网络监管体系构建
在数字化办公时代,构建基于Java技术的单位网络监控软件至关重要。该软件能精准监管单位网络活动,保障信息安全,提升工作效率。通过网络流量监测、访问控制及连接状态监控等模块,实现高效网络监管,确保网络稳定、安全、高效运行。
86 11
|
6天前
|
【Java并发】【线程池】带你从0-1入门线程池
欢迎来到我的技术博客!我是一名热爱编程的开发者,梦想是编写高端CRUD应用。2025年我正在沉淀中,博客更新速度加快,期待与你一起成长。 线程池是一种复用线程资源的机制,通过预先创建一定数量的线程并管理其生命周期,避免频繁创建/销毁线程带来的性能开销。它解决了线程创建成本高、资源耗尽风险、响应速度慢和任务执行缺乏管理等问题。
112 60
【Java并发】【线程池】带你从0-1入门线程池
云栖大会 | Terraform从入门到实践:快速构建你的第一张业务网络
云栖大会 | Terraform从入门到实践:快速构建你的第一张业务网络
Java中的字符集编码入门-增补字符(转载)
本文探讨Java对Unicode的支持及其发展历程。文章详细解析了Unicode字符集的结构,包括基本多语言面(BMP)和增补字符的表示方法,以及UTF-16编码中surrogate pair的使用。同时介绍了代码点和代码单元的概念,并解释了UTF-8的编码规则及其兼容性。
113 60
Java网络编程封装
Java网络编程封装原理旨在隐藏底层通信细节,提供简洁、安全的高层接口。通过简化开发、提高安全性和增强可维护性,封装使开发者能更高效地进行网络应用开发。常见的封装层次包括套接字层(如Socket和ServerSocket类),以及更高层次的HTTP请求封装(如RestTemplate)。示例代码展示了如何使用RestTemplate简化HTTP请求的发送与处理,确保代码清晰易维护。
JAVA网络IO之NIO/BIO
本文介绍了Java网络编程的基础与历史演进,重点阐述了IO和Socket的概念。Java的IO分为设备和接口两部分,通过流、字节、字符等方式实现与外部的交互。
Spring Boot 入门:简化 Java Web 开发的强大工具
Spring Boot 是一个开源的 Java 基础框架,用于创建独立、生产级别的基于Spring框架的应用程序。它旨在简化Spring应用的初始搭建以及开发过程。
114 7
Spring Boot 入门:简化 Java Web 开发的强大工具
鸿蒙应用开发从入门到入行 - 篇7:http网络请求
在本篇文章里,您将掌握鸿蒙开发工具DevEco的基本使用、ArkUI里的基础组件,并通过制作一个简单界面掌握使用
100 8
图卷积网络入门:数学基础与架构设计
本文系统地阐述了图卷积网络的架构原理。通过简化数学表述并聚焦于矩阵运算的核心概念,详细解析了GCN的工作机制。
207 3
图卷积网络入门:数学基础与架构设计
网络编程懒人入门(十六):手把手教你使用网络编程抓包神器Wireshark
Wireshark是一款开源和跨平台的抓包工具。它通过调用操作系统底层的API,直接捕获网卡上的数据包,因此捕获的数据包详细、功能强大。但Wireshark本身稍显复杂,本文将以用抓包实例,手把手带你一步步用好Wireshark,并真正理解抓到的数据包的各项含义。
152 2

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等