Java学习笔记（十八）--网络编程

最新推荐文章于 2023-12-30 22:08:53 发布

yangruxi

最新推荐文章于 2023-12-30 22:08:53 发布

阅读量325

点赞数

分类专栏： JavaSE 文章标签： java 网络编程

本文链接：https://blog.csdn.net/yangruxi/article/details/72823451

版权

JavaSE 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

网络编程

1.网络编程三要素：IP，端口，协议。

2.三要素详解：
（1）IP：一个计算机的标识（找到这个计算机）；
特殊的IP地址：
127.0.0.1 ：本地回环地址，用来做一些本地测试。
ping IP地址：用来检测本机是否可以和指定的IP地址计算机进行正常通讯。
ipconfig：用来查看IP地址。
xxx.xxx.xxx.255：广播地址。

（2）端口：应用程序都会对应一个端口，用来进行通信。
物理端口：物理设备对应的端口。
逻辑端口：用来标记我们计算机上的进程，有效端口：0~65535，其中0~1024被系统使用或保留端口。

（3）协议：两种协议（TCP和UDP）。
UDP：
把数据打包成一个数据包，不需要建立连接；
数据包的大小有限制，不能超过64k；
因为无连接，所以属于不可靠协议；
因为无连接，所以效率高。
TCP：
需要建立连接，形成连接通道；
数据可以使用连接通道直接进行传输，无大小限制；
因为有连接，所以属于可靠协议；
因为有连接，所以效率低。

InetAddress

1.InetAddress：IP地址的描述类。方便了我们对IP地址的获取和操作。

2.InetAddress类的常见功能：

public static InetAddress getByName(String host)（ host: 可以是主机名,也可以是IP地址的字符串表现形式）
public String getHostAddress()返回 IP 地址字符串（以文本表现形式）
public String getHostName()获取此 IP 地址的主机名

需求：获取IP地址字符串，获取此IP地址的主机名。

public class InetAddressDemo {
    public static void main(String[] args) throws Exception {
        ////通过主机IP获取InetAddress对象
        InetAddress address = InetAddress.getByName("192.168.20.120");

        //public String getHostAddress()返回IP地址字符串（以文本表现形式）      
        System.out.println(address.getHostAddress());
        //public String getHostName()获取此IP地址的主机名        
        System.out.println(address.getHostName());

    }

}

运行结果：
192.168.20.120
192.168.20.120

Socket编程（套接字编程，网络编程）

1.Socket套接字：网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

2.Socket编程图解（利用张三和李四在QQ上聊天作为案例来了解）：
这里写图片描述

3.Socket原理机制：
通信的两端都有Socket；
网络通信其实就是Socket间的通信；
数据在两个Socket间通过IO流传输。

UDP协议

1.UDP协议特点：
（1）把数据打包成一个数据包，不需要建立连接；
（2）数据包的大小有限制，不能超过64k；
（3）因为无连接，所以属于不可靠协议；
（4）因为无连接，所以效率高。

2.UDP通信步骤：
发送端步骤：
（1）创建UDP发送数据端Socket对象；
（2）创建数据包，并给出数据，把数据打包；
（3）通过Socket对象发送数据包；
（4）释放资源。
代码实现：

public class UdpClient {
    public static void main(String[] args) throws Exception {
        //1.创建发送端的socket对象
        DatagramSocket ds = new DatagramSocket();

        InetAddress address = InetAddress.getByName("192.168.20.120");
        int port = 6666;

        //2.创建数据包
        byte[] buf = "hello".getBytes();
        int length = buf.length;
        DatagramPacket dp = new DatagramPacket(buf, length, address, port);


        //3.发送数据
        ds.send(dp);

        //4.释放资源
        ds.close();



    }

}

接收端步骤：
（1）创建UDP接收数据端Socket对象；
（2）创建一个接收数据的数据包；
（3）接收数据，数据在数据包中；
（4）解析数据包，并把数据显示在控制台；
（5）释放资源。
代码实现：

public class UdpServer {
    public static void main(String[] args) throws Exception {
        //创建接收端口的socket对象
        DatagramSocket ds = new DatagramSocket(6666);

        //创建一个数据包来接收数据
        byte[] buf = new byte[1024];
        int len = buf.length;
        DatagramPacket dp = new DatagramPacket(buf, len);

        //接收来自发送端的数据
        ds.receive(dp);

        //解析数据包
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));

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

    }
}

3.UDP协议发送和接受数据图解:
这里写图片描述
需求：键盘录入数据实现数据的动态发送。
发送端：

package com.edu_01;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

//键盘录入数据实现数据的动态发送
public class UdpClient {
    public static void main(String[] args) throws Exception {
        //创建发送端的socket对象
        DatagramSocket ds = new DatagramSocket();
        InetAddress address = InetAddress.getByName("192.168.20.120");
        int port = 2000;

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        String line;

        //创建数据包
        while ((line=sc.nextLine())!=null) {
            byte[] buf = line.getBytes();
            int len = buf.length;
            DatagramPacket dp = new DatagramPacket(buf, len, address, port);
            //发送数据包
            ds.send(dp);

        }

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

    }

}

接收端：

package com.edu_01;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpSever {
    public static void main(String[] args) throws Exception {
        //创建接收端的socket对象
        DatagramSocket ds = new DatagramSocket(2000);

        while (true) {
            //创建一个数据包来接收来自发送端的数据包
            byte[] buf = new byte[1024];
            int len = buf.length;
            DatagramPacket dp = new DatagramPacket(buf, 0, len);

            //接收数据包
            ds.receive(dp);

            //解析数据包中的数据
            byte[] data = dp.getData();
            int length = dp.getLength();
            System.out.println(new String(data,0,length));
        }


    }

}

需求：实现客户端和服务器端对话（在本地主机测试）。
客户端：


import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws Exception {
        int clientPort = 5555;
        int serverProt = 6666;

        String clientIp = "Localhost";
        String serverIp = "Localhost";

        InetAddress clientAddress = InetAddress.getByName(clientIp);
        InetAddress serverAddress = InetAddress.getByName(serverIp);

        //创建客户端socket
        DatagramSocket ds = new DatagramSocket(clientPort);

        boolean start = true;
        while(start){
            /**
             * 发送数据
             */
            System.out.print("请输入要发送给服务器的消息:");
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            //创建一个数据包发送数据
            byte[] bytes = line.getBytes();
            int len = bytes.length;
            DatagramPacket dp = new DatagramPacket(bytes,len,serverAddress,serverProt);
            //发送数据包
            ds.send(dp);
            System.out.println("消息发送成功");
            System.out.println("----------------------------------------------------------");

            /**
             * 接收数据
             */
            //创建一个数据包来接收数据
            byte[] bufs = new byte[1024];
            int lens = bufs.length;
            DatagramPacket dps = new DatagramPacket(bufs,0,lens);
            //接收数据包
            ds.receive(dps);
            //解析数据包中的数据
            byte[] data = dps.getData();
            int length = dps.getLength();
            System.out.println("收到来自服务器的消息:"+new String(data,0,length));
        }

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

服务器端：


import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class Server {
    public static void main(String[] args) throws Exception{
        int serverPort = 6666;
        int clientPort = 5555;

        String serverIp = "Localhost";
        String clientIp = "Localhost";

        InetAddress serverAddress = InetAddress.getByName(serverIp);
        InetAddress clientAddress = InetAddress.getByName(clientIp);

        //创建服务器端套接字
        DatagramSocket ds = new DatagramSocket(serverPort,serverAddress);

        boolean start = true;
        while(start){
            System.out.println("服务器端已启动");
            /**
             * 接收数据
             */
            //创建一个数据包来接收数据
            byte[] bytes = new byte[1024];
            int len = bytes.length;
            DatagramPacket dp = new DatagramPacket(bytes,0,len);
            //接收数据
            ds.receive(dp);
            //解析数据包
            byte[] data = dp.getData();
            int length = dp.getLength();
            System.out.println("收到来自客户端的消息:"+new String(data,0,length));

            /**
             * 发送数据
             */
            System.out.print("请输入回复给客户端的消息:");
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            //创建一个数据包来发送数据
            byte[] buf = line.getBytes();
            int lens = buf.length;
            DatagramPacket dps = new DatagramPacket(buf,lens,clientAddress,clientPort);
            //发送数据包
            ds.send(dps);
            System.out.println("消息发送成功");
            System.out.println("----------------------------------------------------------");
        }

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

运行结果（DOS窗口）：
服务器端页面：
这里写图片描述

客户端页面：
这里写图片描述

实现两台主机间的通信：如果在对方电脑启动服务器端，就将serverIp改为对方的Ip。反之，如果在对方电脑启动客户端，就将clientIp改为对方IP。

需求：多线程实现聊天室。
发送端：

package com.edu_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Scanner;

public class UdpClient implements Runnable{


    private DatagramSocket ds;

    public UdpClient(DatagramSocket ds){
        this.ds=ds;
    }

    @Override
    public void run() {
        try {
            InetAddress address = InetAddress.getByName("192.168.20.255");
            int port = 1050;

            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line;
            while ((line=sc.nextLine())!=null) {
                byte[] buf = line.getBytes();
                int length = buf.length;
                DatagramPacket dp = new DatagramPacket(buf, length, address, port);
                //发送数据包
                ds.send(dp);
            }
            //释放资源
            ds.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }

}

接收端：

package com.edu_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpServer implements Runnable{

    private DatagramSocket ds;
    public UdpServer(DatagramSocket ds){
        this.ds=ds;
    }
    @Override
    public void run() {
        try {
            //创建一个数据包来接收发送端传来的数据
            byte[] buf = new byte[1024];
            int length = buf.length;
            DatagramPacket dp = new DatagramPacket(buf, length);

            //接收数据包
            ds.receive(dp);

            //获取发送人的IP
            String ip = dp.getAddress().getHostAddress();

            //解析数据包
            byte[] data = dp.getData();
            int len = dp.getLength();
            System.out.println(ip+new String(data,0,len));

            //释放资源
            ds.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

开启线程：

package com.edu_02;

import java.net.DatagramSocket;
import java.net.SocketException;

public class ChatRoom {
    public static void main(String[] args) throws Exception {
        //开启发送线程
        new Thread(new UdpClient(new DatagramSocket())).start();
        //开启接收线程
        new Thread(new UdpServer(new DatagramSocket(1050))).start();
    }

}

TCP协议

1.TCP协议特点：
（1）需要建立通道；
（2）传送大量数据无限制；
（3）面向连接；
（4）可靠；
（5）效率低。

2.TCP通信步骤：
发送端步骤：
（1）创建TCP协议发送端Socket对象，指定服务器IP及端口；

Socket sk = new Socket（"192.168.20.120",6666）;

（2）获取输出流，并写数据；

 OutputStream outputStream = sk.getOutputStream();
 outputStream.write("hello,TCP".getBytes();

（3）释放资源。

sk.close();

注意：TCP协议是不能直接运行客户端的，必须先运行服务器，因为它是一种可靠协议，否则会报如下异常：java.net.ConnectException: Connection refused: connect。

接收端步骤：
（1）创建TCP协议接收端Socket对象；

ServerSocket ss = new ServerSocket(6666);

（2）监听客户端连接；

Socket sk = ss.accept();

（3）获取输入流，并读取数据，显示在控制台；

// 读取数据
                    byte[] bytes = new byte[1024] ;
                    int len = inputStream.read(bytes) ;

                    // public InetAddress getInetAddress()获取IP地址
                    InetAddress inetAddress = sk.getInetAddress() ;
                    String ip = inetAddress.getHostAddress() ;

                    // 输出
                    System.out.println(ip + "发来数据是: " + new String(bytes , 0 , len));

（4）释放资源。

sk.close();

3.TCP协议发送和接收数据图解：
这里写图片描述
需求：客户端键盘录入数据，服务端将数据写入文件。
客户端：

package com.edu_03;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class TcpClient {
    public static void main(String[] args) throws Exception {
        //创建客户端socket对象
        Socket sk = new Socket("192.168.20.120",1200);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        String line;
        while ((line=sc.nextLine())!=null) {
            //把键盘录入的数据写入通道,一次写一行
            bw.write(line);
            bw.newLine();
            bw.flush();

        }

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

    }

}

服务器端：

package com.edu_03;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    public static void main(String[] args) throws Exception {
        //创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(1200);

        //监听来自客户端的连接
        Socket sk = ss.accept();

        BufferedReader br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        String line;
        while (( line = br.readLine())!=null) {
            //读取数据，一次读取一行
            bw.write(line);
            bw.newLine();
            bw.flush();

        }

        //释放资源
        sk.close();
        br.close();
        bw.close();

    }

}

需求：实现客户端和服务器端的聊天（在一台主机上）。
客户端：


import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws Exception{
        String clientIp = "Localhost";
        int clientPort = 3333;

        InetAddress clientAddress = InetAddress.getByName(clientIp);

        //创建客户端socket对象
        Socket socket = new Socket(clientAddress,clientPort);

        boolean start = true;
        while(start){
            /**
             * 发送消息
             */
            //获取输出流
            OutputStream os = socket.getOutputStream();
            System.out.print("请输入要发送给服务器端的消息:");
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            os.write(line.getBytes());
            System.out.println("消息发送成功");
            System.out.println("------------------------------------------------");

            /**
             * 接收消息
             */
            //获取输入流
            InputStream is = socket.getInputStream();
            byte[] buf = new byte[1024];
            int len = is.read(buf);
            System.out.println("收到来自服务器端的消息:"+new String(buf,0,len));
        }

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

    }
}

服务器端：


import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class Server {
    public static void main(String[] args) throws Exception{
        int serverPort = 3333;

        //创建服务器端socket对象
        ServerSocket ss = new ServerSocket(serverPort);
        System.out.println("服务器端已启动");

        //监听来自客户端的连接
        Socket socket = ss.accept();
        System.out.println("客户端已连接");

        boolean start = true;
        while(start){
            /**
             * 接收消息
             */
            //获取输入流
            InputStream is = socket.getInputStream();
            byte[] buf = new byte[1024];
            int len = is.read(buf);
            System.out.println("收到来自客户端的消息:"+new String(buf,0,len));

            /**
             * 发送消息
             */
            //获取输出流
            OutputStream os = socket.getOutputStream();
            System.out.print("请输入要发送给客户端的消息:");
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            os.write(line.getBytes());
            System.out.println("消息发送成功");
            System.out.println("------------------------------------------------");
        }

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

    }
}

运行结果：
客户端：
这里写图片描述
服务器端：

yangruxi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记（十八）--网络编程

网络编程1.网络编程三要素：IP，端口，协议。2.三要素详解：（1）IP：一个计算机的标识（找到这个计算机）；特殊的IP地址： 127.0.0.1 ：本地回环地址，用来做一些本地测试。 ping IP地址：用来检测本机是否可以和指定的IP地址计算机进行正常通讯。 ipconfig：用来查看IP地址。 xxx.xxx.xxx.255：广播地址。（2）端口：应用程序都会对应一个端口，用
复制链接

扫一扫