• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

JavaSE-网络编程

开发技术 开发技术 6小时前 2次浏览

JavaSE-网络编程

InetAddress

java.net.InetAddress 代表ip的类

这个类没有构造方法,所以不能new ,可以通过其方法返回一个ip的对象

static InetAddress getByName(String host), 在给定主机名的情况下确定主机的 IP 地址,返回一个InetAddress类的对象

String getHostAddress() 返回 IP 地址字符串(以文本表现形式)

String getHostName()返回此IP地址的主机名

URL

URL 代表一个统一资源定位符,它是指向互联网“资源”的指针。资源可以是简单的文件或目录,也可以是对更为复杂的对象的引用,例如对数据库或搜索引擎的查询。

URI 类在某些特定情况下对其组成字段执行转义。建议使用 URI管理 URL 的编码和解码,并使用 toURI()URI.toURL() 实现这两个类之间的转换。

方法

返回值 方法
String getFile()获取此 URL 的文件名。
String getHost() 获取此 URL 的主机名(如果适用)。
String getPath() 获取此 URL 的路径部分。
int getPort() 获取此 URL 的端口号。
String getProtocol() 获取此 URL 的协议名称。
String getQuery() 获取此 URL 的查询部分。
String getRef() 获取此 URL 的锚点(也称为“引用”)。
URI toURI() 返回与此 URL 等效的 URI
URLConnection openConnection() 返回一个 URLConnection 对象,它表示到 URL 所引用的远程对象的连接。
InputStream openStream() 打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream
public class  URLDown {
    public static void main(String[] args) throws Exception{

        URL url = new URL("https://pic.cnblogs.com/avatar/1835657/20210311181843.png");
				//建立与此url对象的http连接
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
				//获取该连接中的输入流
        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("/Users/bjdzbjba0152/Desktop/java2.png");
				//读取输入流并写入文件
        byte[] bytes = new byte[1024];
        int len;
        while ((len = inputStream.read(bytes)) != -1){
            fos.write(bytes, 0, len);
        }
				//关闭资源
        fos.close();
        inputStream.close();
      	//关闭http连接
        urlConnection.disconnect();
    }
}

TCP

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

Socket

构造方法

Socket(InetAddress address, int port)

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

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

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

Socket(Proxy proxy)

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

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

Socket(String host, int port, InetAddress localAddr, int localPort)
创建一个套接字并将其连接到指定远程主机上的指定远程端口。

其他方法

返回值 方法
void bind(SocketAddress bindpoint) 将套接字绑定到本地地址。
void close() 关闭此套接字。
void connect(SocketAddress endpoint) 将此套接字连接到服务器。
void connect(SocketAddress endpoint, int timeout) 将此套接字连接到服务器,并指定一个超时值
InetAddress getInetAddress() 返回套接字连接的地址。
InputStream getInputStream() 返回此套接字的输入流。
InetAddress getLocalAddress() 获取套接字绑定的本地地址。
int getLocalPort() 返回此套接字绑定到的本地端口。
SocketAddress getLocalSocketAddress() 返回此套接字绑定的端点的地址,如果尚未绑定则返回 null
OutputStream getOutputStream() 返回此套接字的输出流。
int getPort() 返回此套接字连接到的远程端口。
SocketAddress getRemoteSocketAddress() 返回此套接字连接的端点的地址,如果未连接则返回 null
boolean isBound() 返回套接字的绑定状态。
boolean isClosed() 返回套接字的关闭状态。
boolean isConnected() 返回套接字的连接状态。
void shutdownInput() 此套接字的输入流置于“流的末尾”。发送到套接字的输入流端的任何数据都将被确认然后被静默丢弃。如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容,则流将返回 EOF(文件结束符)
void shutdownOutput() 禁用此套接字的输出流。对于 TCP 套接字,任何以前写入的数据都将被发送,并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流,则该流将抛出 IOException。

ServerSocket

此类实现服务器套接字。服务器套接字等待请求通过网络传入。

构造方法

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

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

ServerSocket(int port, int backlog, InetAddress bindAddr)使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。

其他方法

返回值 方法名
Socket accept() 侦听并接受到此套接字的连接。
void bind(SocketAddress endpoint)ServerSocket 绑定到特定地址(IP 地址和端口号)。
void bind(SocketAddress endpoint, int backlog)ServerSocket 绑定到特定地址(IP 地址和端口号)。
void close() 关闭此套接字。
InetAddress getInetAddress() 返回此服务器套接字的本地地址。
int getLocalPort() 返回此套接字在其上侦听的端口。
SocketAddress getLocalSocketAddress() 返回此套接字绑定的端点的地址,如果尚未绑定则返回 null

TCP收发消息

TCPClient

  1. 创建socket连接.Socket(inetAddress, port) ,连接server socket ip(InetAddress.getByName("ip")), port
  2. 发送消息,socket.getOutputStream , 利用该方法返回的OutputStream对象.write(message)
  3. 释放资源,先开后关
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os =null;
        //连接socket server
        try {
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");

            int port = 9999;

            //创建socket连接
            socket = new Socket(inetAddress, 9999);

            //发送消息
            os = socket.getOutputStream();
            os.write("Hello i am ClientSocket!".getBytes());

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

TCPServer

  1. 生成一个server socket ,new ServerScoket(port)
  2. 阻塞socket,等待client端的socket连接,Socket.accept()
  3. 准备读取消息,获取accept.getInputStream()对象,这里的accept对象就是client端的socket对象
  4. 使用管道流new ByteArrayOutputStream()读取字节序列
  5. 释放资源,先开后关
public class TcpServerDemo01 {
    public static void main(String[] args) {
        //提升作用域
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //生成一个servser socket
            serverSocket = new ServerSocket(9999);

            //等待客户端连接,这里的accept即为Client端的socket对象
            accept = serverSocket.accept();

            //读取客户端消息
            is = accept.getInputStream();

            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                baos.write(buffer, 0, len);
            }

            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            //管道流 先开后关
            if (baos != null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

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

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

        }
    }
}

TCP文件上传

TCPClient

  1. 创建一个socketnew Scoket(InetAddress.getByName("ip"), port)
  2. 创建一个输出流socket.getOutputStream
  3. 读取要传输的本地文件new FileInputStream(new File("file path"))
  4. 输出文件byte[] buffer,int len,while,此时文件被写入流里
  5. 告知server socket已经传输完成,socket.shutdownOutput
  6. 接受server socket通知socket.getInputStream(), new ByteArrayOutputStream()
  7. 关闭资源,先开后关
public static void main(String[] args) throws Exception{
        //创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);

        //创建一个输出流
        OutputStream os = socket.getOutputStream();

        //读取文件
        FileInputStream fis = new FileInputStream(new File("/Users/b/Desktop/java2.txt"));

        //输出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }

        //告知server socket已经传输完文件
        socket.shutdownOutput();

        //接受server端的通知
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        int len2;
        byte[] buffer2 = new byte[1024];
        while ((len2 = inputStream.read(buffer2)) != -1){
            baos.write(buffer2, 0, len2);
        }
        System.out.println(baos.toString());

        //关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

    }
}

TCPServer

  1. 创建server socket new ServerSocket(int port)
  2. 阻塞socket,等待client端连接serverScoket.accept()
  3. 获取输入流accept.getInputStream
  4. 输出文件到指定位置new FileOutputStream(new File(String filepath))
  5. 通知client已经接受完毕,accept.getOutputstream , .write("msg".getBytes())
  6. 关闭资源,先开后关
public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{

        //创建服务server sockett
        ServerSocket serverSocket = new ServerSocket(9999);

        //监听连接 accept
        Socket accept = serverSocket.accept();

        //获取输入流
        InputStream is = accept.getInputStream();

        //文件输出
        FileOutputStream fos = new FileOutputStream(new File("/Users/b/Desktop/java3.txt"));
        int len;
        byte[] buffer = new byte[1024];
        while ((len = is.read(buffer)) != -1){
            fos.write(buffer, 0, len);
        }

        //通知client端已经接受完了
        OutputStream os = accept.getOutputStream();
        os.write("我已经接受完了,可以关闭socket".getBytes());

        //关闭资源
        fos.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}

UDP

DatagramPacket

此类表示数据报包

数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由,也可能按不同的顺序到达。不对包投递做出保证。

构造方法

DatagramPacket(byte[] buf, int length) 构造 DatagramPacket,用来接收长度为 length 的数据包。

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

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

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

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

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

其他方法

返回值 方法
InetAddress getAddress() 返回某台机器的 IP 地址,此数据报将要发往该机器或者是从该机器接收到的。
byte[] getData() 返回数据缓冲区。new String(packet.getData())接受string类型msg
int getLength() 返回将要发送或接收到的数据的长度。
int getOffset() 返回将要发送或接收到的数据的偏移量。
int getPort() 返回某台远程主机的端口号,此数据报将要发往该主机或者是从该主机接收到的。
SocketAddress getSocketAddress() 获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress(通常为 IP 地址 + 端口号)。
void setAddress(InetAddress iaddr) 设置要将此数据报发往的那台机器的 IP 地址。
void setData(byte[] buf) 为此包设置数据缓冲区。
void setData(byte[] buf, int offset, int length) 为此包设置数据缓冲区。
void setLength(int length) 为此包设置长度。
void setPort(int iport) 设置要将此数据报发往的远程主机上的端口号。
void setSocketAddress(SocketAddress address) 设置要将此数据报发往的远程主机的 SocketAddress(通常为 IP 地址 + 端口号)。

DatagramSocket

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

数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由,也可能按不同的顺序到达。

构造方法

DatagramSocket() 构造数据报套接字并将其绑定到本地主机上任何可用的端口。

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

DatagramSocket(int port, InetAddress laddr) 创建数据报套接字,将其绑定到指定的本地地址。

DatagramSocket(SocketAddress bindaddr) 创建数据报套接字,将其绑定到指定的本地套接字地址。

其他方法

返回值 方法
void bind(SocketAddress addr) 将此 DatagramSocket 绑定到特定的地址和端口。
void close() 关闭此数据报套接字。
void connect(InetAddress address, int port) 将套接字连接到此套接字的远程地址。
void connect(SocketAddress addr) 将此套接字连接到远程套接字地址(IP 地址 + 端口号)。
void disconnect() 断开套接字的连接。
InetAddress getInetAddress() 返回此套接字连接的地址。
InetAddress getLocalAddress() 获取套接字绑定的本地地址。
int getLocalPort() 返回此套接字绑定的本地主机上的端口号。
SocketAddress getLocalSocketAddress() 返回此套接字绑定的端点的地址,如果尚未绑定则返回 null
int getPort() 返回此套接字的端口。
SocketAddress getRemoteSocketAddress() 返回此套接字连接的端点的地址,如果未连接则返回 null
boolean isBound() 返回套接字的绑定状态。
boolean isClosed() 返回是否关闭了套接字。
boolean isConnected() 返回套接字的连接状态。
void receive(DatagramPacket p) 从此套接字接收数据报包。
void send(DatagramPacket p) 从此套接字发送数据报包。

UDP收发消息

UDPClient

  1. 创建DtagramSocket,new DatagramSocket
  2. 创建UDP数据包,String msg, InetAddress.getByName("ip"),int port ,new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, InetAddress.getByName("ip"), port)
  3. 发送数据包datagramSocket.send(datagramPacket)
  4. 释放资源datagramSocket.close()
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception{

        //建立一个datagramsocket
        DatagramSocket datagramSocket = new DatagramSocket();

        //建立数据包
        String msg = "Hello UDPServer";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9999;

        DatagramPacket datagramPacket = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //发送数据包
        datagramSocket.send(datagramPacket);

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


    }
}

UDPServer

  1. 创建DatagramSocket,new DatagramSocket(port)
  2. 接受数据包(阻塞接受)new byte[1024],new DatagramPacket(buffer, 0, buffer.length) datagramSocket.recive(packet)
  3. 输出信息packet.getxxx()
  4. 释放资源datagramSocket.close()
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception{

        //创建datagramSocket
        DatagramSocket datagramSocket = new DatagramSocket(9999);

        //接受数据包
        byte[] buffer = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buffer,0,buffer.length);
        datagramSocket.receive(datagramPacket); //阻塞接受

        //输出
        System.out.println("getAddress().getHostAddress(): " + datagramPacket.getAddress().getHostAddress());
        System.out.println("getData(): "+ datagramPacket.getData());
        System.out.println("new String(packet.getData()): " + new String(datagramPacket.getData()));
        System.out.println("getLength(): " + datagramPacket.getLength());
        System.out.println("getSocketAddress(): " + datagramPacket.getSocketAddress());
        System.out.println("getPort(): " + datagramPacket.getPort());
        System.out.println("getOffset: " + datagramPacket.getOffset());

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

    }
}

程序员灯塔
转载请注明原文链接:JavaSE-网络编程
喜欢 (0)