java网络编程笔记

最新推荐文章于 2023-12-31 10:45:56 发布

fouo uooa

最新推荐文章于 2023-12-31 10:45:56 发布

阅读量160

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_45643377/article/details/119062395

版权

java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、 TCP协议：传输控制协议

使用tcp协议前，需先建立TCP连接，形成传输数据通道，
传输前，采用三次握手方式，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端
在连接中，课进行大量数据的传输
传输完毕，需释放已建立的连接，效率低

一下为一个简单的聊天程序：

1.1 字节流传输

服务端

public class TcpServerDemo {

    public static void main(String[] args) throws IOException, IOException {

        // 1.监听端口号
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器启动！等待连接...");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接；如果有客户端连接，则会返回Socket对象，程序继续
        Socket clientSocket = serverSocket.accept();
        System.out.println("服务端连接：" + clientSocket.getClass().getName());

        // 3. 获取输入流，接收到客户端发送的消息
        InputStream inputStream = clientSocket.getInputStream();
        //读取流中的数据
        int i;
        StringBuilder stringBuilder = new StringBuilder();
        System.out.print("客户端发来的消息：");
        while ((i = inputStream.read()) != -1) {
            stringBuilder.append((char) i);
        }
        System.out.print(stringBuilder);

        // 4. 获取对应客户端的输出流，向客户端发送消息
        OutputStream outputStream = clientSocket.getOutputStream();
        outputStream.write((stringBuilder + "（服务器消息）").getBytes());
        clientSocket.shutdownOutput();  //输出写入结束标志，很重要！ 否则会阻塞


        //关闭操作
        outputStream.close();
        serverSocket.close();
        inputStream.close();

    }
}

客户端，客户端也会有自己的端口，此端口是启动时随机分配的。

public class TcpClientDemo {


    public static void main(String[] args) throws IOException {

        // 1. 连接服务端（ip，端口），因为此时是在本机上，所以是本机ip
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端连接：" + socket.getClass().getName());

        // 2. 用输出流向服务端发送数据，发送的hello
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello".getBytes());
        socket.shutdownOutput();  //输出写入结束标志，很重要！ 否则会阻塞


        // 3. 获取输入流，得到服务端发送的数据
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int redLin = 0;
        while ((redLin = inputStream.read(bytes)) != -1) {
            System.out.println("服务器发来的消息：" + new String(bytes, 0, redLin));
        }

        //关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出");
    }

}

1. 2 字符流传输

如果客户端使用字符流传输，那么服务端要使用字符流读取
服务端代码：

public class TcpServerDemo {

    public static void main(String[] args) throws IOException, IOException {

        // 1.监听端口号
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器启动！等待连接...");
        //2.当没有客户端连接9999端口时，程序会阻塞，等待连接；如果有客户端连接，则会返回Socket对象，程序继续
        Socket clientSocket = serverSocket.accept();
        System.out.println("服务端连接：" + clientSocket.getClass().getName());

        // 3. 获取输入流，接收到客户端发送的消息
        InputStream inputStream = clientSocket.getInputStream();
//        int read = inputStream.read();  //因为客户端使用的是字符流发送，所以字节流读取不到
        
        //转为字符流读取
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String str = bufferedReader.readLine();
        System.out.println(str);


        // 4. 获取对应客户端的输出流，向客户端发送消息
        OutputStream outputStream = clientSocket.getOutputStream();
        // 转为字符流输出
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));

        bufferedWriter.write((str + "字符流，（服务器消息）"));
        bufferedWriter.newLine();  // 如果用字符输出流，这个表示结束输出标志
        bufferedWriter.flush(); //要刷新（关闭操作也可以写进去），否则写不进去

        //关闭操作
        bufferedWriter.close();
        outputStream.close();
        serverSocket.close();
        inputStream.close();

    }
}

客户端

public class TcpClientDemo {

    public static void main(String[] args) throws IOException {

        // 1. 连接服务端（ip，端口），因为此时是在本机上，所以是本机ip
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端连接：" + socket.getClass().getName());

        // 2. 用输出流向服务端发送数据，发送的hello
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello");// 如果用字符输出流，这个表示结束输出标志
        bufferedWriter.newLine(); //  字符流的输出结束标志
        bufferedWriter.flush();  //要刷新（关闭操作也可以写进去），否则写不进去


        // 3. 获取输入流，得到服务端发送的数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(bufferedReader.readLine());

        //关闭

        bufferedReader.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出");
    }

}

2、UDP

将数据封装成数据包，不建立连接
每个数据包的大小为64kb，不适合大量数据
因无需连接，所以是不可靠的
发送数据结束时不需要释放资源（因为不是面向连接的），速度快
例如：发短信

例：
ReceivesA：

public class ReceivesA {

    public static void main(String[] args) throws Exception {
        // 1、先建立一个DatagramSocket对象，监听本机的9999端口，准备从端口获取数据，端口不能被其他程序占用
        DatagramSocket socket = new DatagramSocket(9999);

        // 2、创建一个DatagramPacket对象，准备接收数据, 数据包最大为64kb
        byte[] b = new byte[1024];
        DatagramPacket packet = new DatagramPacket(b, b.length);

        // 3、调用接收方法，将数据封装到DatagramPacket中；
        // 如果没有接受到数据，就有阻塞，类似于TCP中服务端中的accept
        socket.receive(packet);

        // 4、从DatagramPacket中拆包取出数据
        int length = packet.getLength();  //实际接收到的数据长度
        byte[] data = packet.getData();  // 实际接收到的数据
        String string = new String(data, 0, length);
        System.out.println(string);

        // 5、封装数据，向B发送
        byte[] send = "A端接受完毕。（来自A）".getBytes();
        // 将数据（数据为字节数组）封装到DatagramPacket，并且指定对方的ip和端口
        packet = new DatagramPacket(send,send.length, InetAddress.getByName("127.0.0.1"),9998);
        socket.send(packet);


        System.out.println("A端退出");
        socket.close();
    }
}

sendB：

public class SenderB {

    public static void main(String[] args) throws Exception {
        //1、监听端口，准备从端口获取数据
        DatagramSocket socket = new DatagramSocket(9998);

        byte[] b = "hello 明天吃火锅".getBytes();
        //2、将数据（数据为字节数组）封装到DatagramPacket，并且指定对方的ip和端口
        DatagramPacket packet = new DatagramPacket(b, b.length, InetAddress.getByName("127.0.0.1"), 9999);

        //3、向A发送消息
        socket.send(packet);

        //4、接收A的回复消息
        socket.receive(packet);
        byte[] data = packet.getData();
        System.out.println(new String(data,0,data.length));

        System.out.println("B端退出");
        socket.close();


    }
}

用子线程来不断接收消息：

public class UDPSend {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(8888);

        Scanner sc = new Scanner(System.in);
        //在线程里面不断接收数据
        receive(socket);
        
        //主线程里发送消息
        while (true) {

            String sendMsg = sc.next();
            byte[] bytes = sendMsg.getBytes();
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), 9999);
            socket.send(packet);

            if (sendMsg.equals("886")) {
                break;
            }

        }

        socket.close();

    }


    public static void receive(DatagramSocket socket) throws Exception {
        byte[] b = new byte[1024];
        DatagramPacket packet = new DatagramPacket(b, b.length);

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        socket.receive(packet);
                        int length = packet.getLength();
                        byte[] data = packet.getData();
                        String receiveMsg = new String(data, 0, length);
                        System.out.println(packet.getPort() + "：" + receiveMsg);
//                        if (receiveMsg.equals("886")) {
//                            break;
//                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }.start();

    }
}

2.1 组播

1、组播是指把信息同时传递给一组目的地址，组播的地址范围时候224.0.0.0~239.255.255.255,如果超过了这个范围就会抛出异常
2、参数组播的所有主机的Socket必须是MulticastSocket类的对象，他是DatagramSocket的子类，因此组播的Socket也是UDP协议的一种

接收端：

public class UDPMulticastReceive {

    public static void main(String[] args) throws Exception {
        MulticastSocket multicastSocket = new MulticastSocket(8888);
        //加入组播
        //ip地址的范围 224.0.0.0 ~  239.255.255.255 范围即可
        multicastSocket.joinGroup(InetAddress.getByName("225.0.0.11"));

        byte[] b = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(b, b.length);
        BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream("src\\com\\day24\\udpMulticast\\1.txt", true)));
        writer.write("写入开始");
        //需要换行和刷新，才能写进去
        writer.newLine();
        writer.flush();

        while (true) {
            Thread.sleep(1000);
            multicastSocket.receive(datagramPacket);
            int len = datagramPacket.getLength();
            byte[] data = datagramPacket.getData();
            String s = new String(data, 0, len);
            System.out.println(s);
            writer.write(datagramPacket.getAddress() + "：" + s);
            writer.newLine();
            writer.flush();
            System.out.println("写入成功");
        }

    }
}

发送端：

public class UDPMulticastSend {

    public static void main(String[] args) throws Exception {

        MulticastSocket ms = new MulticastSocket();
        //加入组播
//        ms.joinGroup(InetAddress.getByName("225.0.0.11"));

//        Scanner sc = new Scanner(System.in);
//        String s = sc.next();

            String s = "";
            DatagramPacket dp = new DatagramPacket(s.getBytes(), s.getBytes().length, InetAddress.getByName("225.0.0.11"), 8888);
            ms.send(dp);
            System.out.println(s);

    }

}