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();
        }
    }
}


相关文章
|
7天前
|
网络协议 网络安全 数据中心
|
22小时前
|
JavaScript 前端开发 Java
Java入门软件及基础语法
**摘要:** - **IDEA:** IntelliJ IDEA,顶级Java开发环境,支持Java,JS,JQuery,Ajax调试. - **JDK:** Java开发包含编译器`javac`,JVM,辅助运行Java程序,核心含JRE,tools.jar,rt.jar. - **Git:** 分布式版本控制,管理源代码,支持回溯,协作,远程备份. - **基础语法:** - `if`: 控制流,单/多分支选择,可嵌套,省略单行大括号. - `switch`: 表达式匹配`case`值,执行对应代码,需`break`防穿透.
|
9天前
|
存储 安全 Java
Java的基础入门(2)
Java的基础入门(2)
|
9天前
|
Java
|
9天前
|
XML Java 程序员
|
16天前
|
传感器 数据采集 监控
Java串口编程入门
Java串口编程入门
|
17天前
|
网络协议 安全 Java
Java中的网络编程:Socket编程详解
Java中的网络编程:Socket编程详解
|
15天前
|
监控 安全 网络安全
|
4天前
|
网络协议 Java Linux
|
16天前
|
安全 Java 网络安全
Java网络编程:高级应用与安全性探讨
Java网络编程:高级应用与安全性探讨