Java网络编程

最新推荐文章于 2024-06-27 11:12:57 发布

旧印

最新推荐文章于 2024-06-27 11:12:57 发布

阅读量52

点赞数

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

本文链接：https://blog.csdn.net/qq_40699041/article/details/118255949

版权

网络编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

网络通信的要素

网络编程中有两个主要的问题
- 如何准确的定位网络上的一台或者多台主机
- 找到主机之后如何进行通信
网络编程中的要素
- IP和端口号
- 网络通信协议(tcp、udp)

IP

ip地址：InetAddress

唯一定位一台网络上的计算机

127.0.0.1：本机地址

示例：

// 测试IP
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            // 查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);   // /127.0.0.1

            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);   // /127.0.0.1

            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            // 查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);   // www.baidu.com/112.80.248.76

            System.out.println("=============================");
            System.out.println(InetAddress.getLoopbackAddress());   // 表示回送地址

            // 常用方法
            System.out.println("=============================");
            // System.out.println(Arrays.toString(inetAddress2.getAddress()));	// 不常用
            System.out.println(inetAddress2.getHostAddress());
            System.out.println(inetAddress2.getHostName());
            System.out.println(inetAddress2.getCanonicalHostName());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

示例：地址：端口

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);

        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());
        System.out.println(inetSocketAddress.getPort());
        System.out.println(inetSocketAddress.getHostString());
    }
}

端口

端口：可以表示计算机上一种程序的进程

不同的进程有不同的端口号！用来区分软件！
被规定0~65535
TCP、UDP：两种协议下都有65535个端口号。在不同的协议下，端口号可一致
端口分类：
- 公有端口0~1023
  - HTTP：80
  - HTTPS：443
  - FTP：21
  - Telnet：23
- 程序注册端口：1024~49151，分配给用户或者程序
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
- 动态、私有：49152-65535
```
netstat -ano	#查看所有端口
netstat -ano|findstr "端口号"	#查看指定端口
tasklist|findstr "端口号"	#查看指定端口的进程
```

通信协议

协议：约定

TCP/IP协议簇

重要：

TCP：用户传输协议
UDP：用户数据报协议

出名的协议：

TCP、IP：网络互连协议

TCP、UDP对比

TCP：打电话

连接，稳定

三次握手 四次挥手

最少需要三次，保证稳定连接！
A：你瞅啥？
B：瞅你咋地？
A：干一场！

A：我要走了！
B：我真的要走了吗？
B：你真的真的要走了吗？
A：我的真的要走了！

客户端、服务端
传输完成，释放连接，效率低

UDP：发短信

不连接，不稳定
客户端、服务商：没有明确的界限
不管有没有准备好，都可以发给你

TCP

客户端：

连接服务器
发送消息

// 客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            // 1.要知道服务器的地址
            InetAddress serverIp = InetAddress.getByName("127.0.0.1");
            // 2.端口号
            int port = 9999;
            // 3.创建一个Socket连接
            socket = new Socket(serverIp, port);
            // 4.发送消息   IO流
            os = socket.getOutputStream();
            os.write("fkeuwgqtllb".getBytes(StandardCharsets.UTF_8));
        } 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();
                }
            }
        }
    }
}

服务器：

建立服务的端口ServerSocket
等待用户的连接accept
接收用户的消息

// 服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 1.我得有一个地址
            serverSocket = new ServerSocket(9999);
            // 2.等待客户端连接过来
            socket = serverSocket.accept();
            // 3.读取客户端的消息
            is = socket.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 (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

文件上传

服务端：

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一起等待
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream("receive.png");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }

        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes(StandardCharsets.UTF_8));

        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端：

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件
        FileInputStream fis = new FileInputStream("wallhaven-pk8pzj.png");
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }
        //通知服务器，我已经传输完了
        socket.shutdownOutput();    //我已经传输完了

        //确定服务器接收完毕，才能够断开连接
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = is.read(buffer2)) != -1) {
            baos.write(buffer2, 0, len2);
        }
        System.out.println(baos.toString());

        //5.关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

Tomcat

Tomcat在控制台打印日志乱码

原因：是因为控制台中的字符串编码格式与Tomcat默认编码不一致

解决方法：

只需要在Tomcat目录下的conf/logging.properties文件中加入如下语句：

修改或增加：java.util.logging.ConsoleHandler.encoding = GBK

8.0版本不会出现此问题

UDP

特点：不用连接，需要知道对方的地址

两个类：

DatagramPacket：数据包

DatagramSocket：用于发送和接收数据包套接字

示例1：

发送端：

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好啊，服务器！";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9000;
        //数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(StandardCharsets.UTF_8),0,msg.getBytes().length,
                localhost,port);
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端：

public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //1.开放端口
        DatagramSocket socket = new DatagramSocket(9000);
        //2.接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接收
        socket.receive(packet); //阻塞接收
        System.out.println(packet.getAddress().getCanonicalHostName());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        //3.关闭连接
        socket.close();
    }
}

示例2：UDP聊天实现

发送端：

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据：控制台读取System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String msg = reader.readLine().trim();
            InetAddress host = InetAddress.getByName("localhost");
            int port = 9000;
            DatagramPacket packet = new DatagramPacket(msg.getBytes(StandardCharsets.UTF_8),
                    0,msg.getBytes().length,host,port);

            socket.send(packet);

            if ("bye".equals(msg)) {
                break;
            }
        }

        socket.close();
    }
}

接收端：

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(9000);

        byte[] container = new byte[1024];

        while (true) {
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);

            socket.receive(packet);
            //断开连接  bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if ("bye".equals(receiveData.substring(0, 3))) {
                break;
            }
        }

        socket.close();
    }
}

示例3：UDP多线程在线咨询

两个人都可以是发送方，也都可以是接收方

//发送端
public class TalkSend implements Runnable {
    DatagramSocket socket;
    BufferedReader reader;

    private int fromPort;
    private String toIp;
    private int toPort;

    public TalkSend(int fromPort, String toIp, int toPort) {
        this.fromPort = fromPort;
        this.toIp = toIp;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            String msg;
            try {
                msg = reader.readLine();
                DatagramPacket packet = new DatagramPacket(msg.getBytes(StandardCharsets.UTF_8),
                        0, msg.getBytes().length, new InetSocketAddress(toIp, toPort));
                InetSocketAddress.createUnresolved(toIp, toPort);
                socket.send(packet);

                if ("bye".equals(msg)) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        try {
            assert reader != null;
            reader.close();
            assert socket != null;
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//接收端
public class TalkReceive implements Runnable {
    DatagramSocket socket;
    private int port;
    private String msgFrom;

    public TalkReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {
            try {
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);

                socket.receive(packet);
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom + "：" + receiveData);

                if ("bye".equals(receiveData.substring(0, 3))) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

//学生端
public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"127.0.0.1",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

//教师端
public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"127.0.0.1",8888)).start();
        new Thread(new TalkReceive(9999,"小明")).start();
    }
}

URL

统一资源定位符：定位资源的，定位互联网上的某一个资源

协议：//ip地址：端口/项目名/资源

示例1：

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8081/helloworld/index.jsp?username=fkeuwgqtllb&password=qwe123");
        System.out.println(url.getProtocol());  //协议：http
        System.out.println(url.getHost());  //主机ip：localhost
        System.out.println(url.getPort());  //端口：8081
        System.out.println(url.getPath());  //文件：/helloworld/index.jsp
        System.out.println(url.getFile());  //全路径：/helloworld/index.jsp?username=fkeuwgqtllb&password=qwe123
        System.out.println(url.getQuery()); //参数：username=fkeuwgqtllb&password=qwe123
    }
}

示例2：下载文件

public class UrlDown {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://m801.music.126.net/20210626225926/a9b2048dda19c8586c08167a02d59600/jdyyaac/030e/0459/5608/4d262f5a0333eaf07f29abc9e123c63c.m4a");
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();
        byte[] buffer = new byte[1024];
        int len;
        FileOutputStream fos = new FileOutputStream("f.m4a");
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        fos.close();
        is.close();
        urlConnection.disconnect();	//关闭连接
    }
}

旧印

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java网络编程

网络编程网络通信的要素网络编程中有两个主要的问题如何准确的定位网络上的一台或者多台主机找到主机之后如何进行通信网络编程中的要素IP和端口号网络通信协议(tcp、udp)IPip地址：InetAddress唯一定位一台网络上的计算机127.0.0.1：本机地址示例：// 测试IPpublic class TestInetAddress { public static void main(String[] args) { try {
复制链接

扫一扫

专栏目录