Java网络编程总结

最新推荐文章于 2024-04-29 21:08:01 发布

Sunwenyan_

最新推荐文章于 2024-04-29 21:08:01 发布

阅读量42

点赞数

文章标签：网络 udp tcp/ip java

本文链接：https://blog.csdn.net/Sunwenyan_/article/details/131258753

版权

InetAdress

常用方法

public static InetAddress getLocalHost() 返回本地主机
public static InetAddress getByName(String host) 根据ip和主机名获取InetAddress
public String getHostAddress() 获取ip地址
public String getHostName() 获取主机名

##代码演示

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {

        // 获取本地主机InetAddress
        InetAddress localHost = InetAddress.getLocalHost();

        System.out.println(localHost.getHostName());
        System.out.println(localHost.getHostAddress());

        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~");

        // 根据主机名获取InetAddress
        InetAddress inetAddress = InetAddress.getByName("DESKTOP-2BQ3L0I");
        System.out.println(inetAddress);

        System.out.println(inetAddress.getHostName());
        System.out.println(inetAddress.getHostAddress());

    }
}

UDP通信

UDP发送数据

UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送、接受数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念。

DatagramSocket的构造方法

DatagramSocket() 创建数据库套接字并将其绑定到本机地址上的任何可用的端口
DatagramPacket(byte[] buf, int len, InetAddress add, int port)创
建数据包，发送长度为len的数据包到指定主机的指定端口

DatagramSocket常用方法

void send(Datagrampacket p) 发送数据报包
void close() 关闭数据报套接字
void receive(DatagramPacket p) 从此套接字接受数据报包

DatagramSocket使用步骤

创建发送端的Socket对象(DatagramSocket)
创建数据，并把数据打包
调用DatagramSocket对象的方法发送数据
关闭发送端

DatagramSocket代码实现

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        DatagramSocket ds = new DatagramSocket();

        //创建数据，并把数据打包
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();

        DatagramPacket dp = new 	DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);

        //调用DatagramSocket对象的方法发送数据
        //void send(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);

        //关闭发送端
        //void close() 关闭此数据报套接字
        ds.close();
    }
}

UDP接受数据

DatagramPacket类构造

DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接受长度为len的数据包

DatagramPacket类方法

byte[] getData() 返回数据缓冲区
int getLength() 返回要发送的数据的长度或接受的数据的长度

接受数据的步骤

创建接收端的Socket对像(DatagramSocket)
创建一个数据包，用于接受数据
调用DatagramSocket对象的方法接受数据
解析数据包，并把数据在控制台显示
关闭接收端

接受数据代码实现

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0,                                             dp.getLength()));
        }
    }
}

TCP通信

TCP发送数据

Java对于基于TCP协议的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。

Socket类构造

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

Socket类方法

inputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

代码实现

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("127.0.0.1",10000);

        //获取输出流，写数据
        //OutputStream getOutputStream() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //释放资源
        s.close();
    }
}

TCP接收数据

ServerSocket类构造

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

ServerSocker类方法

Socket accept() 监听要连接到此的套接字并接受它

代码实现

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);

        //Socket accept() 侦听要连接到此套接字并接受它
        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通信程序案例

案例需求

客户端：发送数据，接收服务器反馈
服务器：收到信息后给出反馈

需求分析

客户端创建对象，使用输出流输出数据
服务器创建对象，使用输入流接收数据
服务器使用输出流给出反馈数据
客户端使用输入流接收反馈数据

代码实现

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个Socket对象
        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());

        //释放资源
//        s.close();
        ss.close();
    }
}

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        Socket s = new Socket("127.0.0.1", 10000);

        //获取输出流，写数据
        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);

        //释放资源
//        is.close();
//        os.close();
        s.close();
    }
}

综合案例

聊天程序案例

发送端

public class UDPSend {
    public static void main(String[] args) throws IOException {
        // 创建DatagramSocket对象
        DatagramSocket socket = new DatagramSocket();
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入聊天内容:");
            String message = sc.nextLine();
            byte[] bytes = message.getBytes();

            // 发送数据
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, InetAddress.getLocalHost(), 10086);

            socket.send(datagramPacket);
        }



        // 释放资源
        // socket.close();
        
    }
}

接收端

public class UDPReceive {
    public static void main(String[] args) throws IOException {
        
        // 创建DategramSorcket并指定端口号
        DatagramSocket datagramSocket = new DatagramSocket(10086);
        byte[] bys = new byte[1024];

        while (true) {

            DatagramPacket datagramPacket = new DatagramPacket(bys,bys.length);
            datagramSocket.receive(datagramPacket);

            byte[] data = datagramPacket.getData();
            int length = datagramPacket.getLength();

            InetAddress address = datagramPacket.getAddress();
            System.out.println("发送者:" + address.getHostAddress());
            System.out.println(new String(data,0,length));
        }

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

    }
}

文件上传案例

案例分析

1、【客户端】输入流，从硬盘读取文件数据到程序中。
2、【客户端】输出流，写出文件数据到服务器。
3、【服务端】输入流，读取文件数据到服务器程序。
4、【服务器】输出流，写出文件数据到服务器硬盘中。
5、【服务器】获取输出流，回写数据。
6、【客户端】获取输入流，解析回写数据

代码实现

服务端实现

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/*
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                ) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                        bos.write(b, 0, len);
                    }

                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================

                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端代码实现

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据.
        byte[] b  = new byte[1024 * 8 ];
        int len ;
        while (( len  = bis.read(b))!=-1) {
            bos.write(b, 0, len);
        }
      	// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================

        // 4.释放资源
        socket.close();
        bis.close();
    }
}