【Java】网络编程

最新推荐文章于 2024-04-20 07:00:00 发布
最新推荐文章于 2024-04-20 07:00:00 发布
阅读量152 收藏
点赞数
分类专栏： java 文章标签： java socket 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxfhahaha/article/details/109326639
版权

网络编程

网络通信要素

  1. 如何实现网络中的主机互相通信
  • 通信双方地址
    IP：网络当中唯一定位的一台主机
    端口号：定位一个主机上不同的应用程序
  • 一定的规则（即：网络通信协议。有两套参考模型）
    OSI参考模型
    TCP/IP参考模型（用的是这个）

通信要素1：IP和端口号

IP

  1. IP：唯一的标识Internet上的计算机
  2. 在Java中使用InetAddress类代表IP
  3. IP分类的两种方式
  • 分类方式1：IPV4和IPV6
  • 分类方式2：万维网（公网地址）和局域网（私有地址）
  1. 域名
    可以通过域名来访问， 会把域名再解析成ip地址
  2. 本地回路地址
    127.0.0.1 表示的是本机，对应localhost
InetAddress类
实例化
  1. getByName(String host)
    host可以是具体的ip地址，也可以是域名
try {
    //用ip地址
    InetAddress inet1 = InetAddress.getByName("192.168.10.13");
    System.out.println(inet1);// /192.168.10.13
    //用域名
    InetAddress inet2 = InetAddress.getByName("www.sina.com");
    System.out.println(inet2);// www.sina.com/112.48.153.229
    //本地
    InetAddress inet3 = InetAddress.getByName("127.0.0.1");
    System.out.println(inet3);// /127.0.0.1

} catch (UnknownHostException e) {
    e.printStackTrace();
}
  1. getLocalHost()
    获取本机的ip地址
InetAddress inet4 = InetAddress.getLocalHost();
System.out.println(inet4);//DESKTOP-02DMF3C/10.30.164.174 因为是局域网所以显示的不是127.0.0.1
常用方法：getHostName()

获取域名

System.out.println(inet2.getHostName());//www.sina.com
常用方法：getHostAddress()

获取ip地址

System.out.println(inet2.getHostAddress());//112.48.153.229

端口号

  1. 端口号标识正在计算机上运行的进程（程序）
  2. 要求不同的进程有不同的端口号
  3. 范围：被规定为一个16位的整数0~65535
  4. 端口号和IP地址的组合得出一个网络套接字Socket

通信要素2：网络协议

在这里插入图片描述
在这里插入图片描述

TCP网络编程

TCP 效率低 但安全 生活中的案例：打电话
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

例子1：客户端发送信息给服务端，服务端将数据显示在控制台上

要先运行服务器端，再运行客户端

客户端步骤：

  1. 创建Socket对象，指明服务器端的ip和端口号
  2. 获取输出流，用于输出数据
  3. 写数据
  4. 资源关闭

服务器端步骤：

  1. 创建服务器端的ServerSocket，指明自己的端口号
  2. 调用accept()表明接收来自于客户端的socket
  3. 获取输入流
  4. 读取输入流的数据
  5. 资源的关闭
public class TCPTest1 {

    //客户端
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        try {
            //1. 创建Socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet,8899);
            //2. 获取输出流，用于输出数据
            os = socket.getOutputStream();
            //3. 写数据
            os.write("您好，我是客户端".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 资源关闭
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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


    }

    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 1. 创建服务器端的ServerSocket，指明自己的端口号
            ss = new ServerSocket(8899);
            //2. 调用accept()表明接收来自于客户端的socket
            socket = ss.accept();
            //3. 获取输入流
            is = socket.getInputStream();
            //不建议这样写，可能会有乱码 因为可能会把一个汉字有三个字节 劈成两半
//        byte[] buffer = new byte[20];
//        int len;
//        while((len=is.read(buffer))!=-1){
//            String str = new String(buffer,0,len);
//            System.out.println(str);
//        }
            //4. 读取输入流的数据
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len); //ByteArrayOutputStream类里面有数组，不够会自动扩 所以就不用怕把汉字批两半
            }
            System.out.println(baos.toString());
            System.out.println("收到了来自于："+socket.getInetAddress().getHostAddress()+"的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5. 资源的关闭
            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(ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }





    }
}
例子2：客户端发送文件给服务端，服务端将文件保存在本地

和例子1的区别就是多了一个文件读写的步骤

public class FileReaderWriterTest {

    //客户端
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        try {
            //1. 创建Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
            //2. 获取输出流，用于输出数据
            os = socket.getOutputStream();
            //3. 写数据
            fis = new FileInputStream(new File("ddd.png"));
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 资源关闭
            if(fis!=null){
                try {
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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


    }

    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        FileOutputStream fos = null;
        try {
            // 1. 创建服务器端的ServerSocket，指明自己的端口号
            ss = new ServerSocket(9090);
            //2. 调用accept()表明接收来自于客户端的socket
            socket = ss.accept();
            //3. 获取输入流
            is = socket.getInputStream();

            //4. 读取输入流的数据
            fos = new FileOutputStream(new File("dddserver.png"));
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){//把从客户端读到的 存在文件中
                fos.write(buffer,0,len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5. 资源的关闭
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            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(ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }





    }
}
例子3：返回“发送成功”给客户端
public class FileReaderWriterTest {

    //客户端
    @Test
    public void client(){
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1. 创建Socket对象，指明服务器端的ip和端口号
            socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
            //2. 获取输出流，用于输出数据
            os = socket.getOutputStream();
            //3. 写数据
            fis = new FileInputStream(new File("ddd.png"));
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }
            //关闭数据的输出
            socket.shutdownOutput();

            //4. 接收来自于服务器端的数据，并显示到控制台上
            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[20];
            int len1;
            while((len1=is.read(buffer1))!=-1){
                baos.write(buffer1,0,len1);
            }
            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 5. 资源关闭
            if(fis!=null){
                try {
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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


    }

    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            // 1. 创建服务器端的ServerSocket，指明自己的端口号
            ss = new ServerSocket(9090);
            //2. 调用accept()表明接收来自于客户端的socket
            socket = ss.accept();
            //3. 获取输入流
            is = socket.getInputStream();

            //4. 读取输入流的数据
            fos = new FileOutputStream(new File("dddserver1.png"));
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){//把从客户端读到的 存在文件中
                fos.write(buffer,0,len);
            }

            //5. 服务器端给客户端反馈
            os = socket.getOutputStream();
            os.write("文件已收到".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6. 资源的关闭
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            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(ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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





    }
}

UDP网络编程

UDP生活中案例：发短信 发电报
在这里插入图片描述

public class UDPTest1 {

    //发送端
    @Test
    public void send() throws IOException {
        DatagramSocket socket = new DatagramSocket();
        String str = "我是UDP方式发送的字符串";
        byte[] data = str.getBytes();
        InetAddress inet = InetAddress.getByName("127.0.0.1");
        DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
        socket.send(packet);

        socket.close();
    }
    //接收端
    @Test
    public void receive() throws IOException {
        DatagramSocket socket = new DatagramSocket(9090);
        byte[] buffer = new byte[100];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        socket.receive(packet);
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        socket.close();
    }
}

URL编程

  1. URL(Uniform Resource Locator) : 统一资源定位符，对应着互联网的某一资源地址
  2. 格式：
    在这里插入图片描述

URL 常用方法

在这里插入图片描述

示例 从服务器下载图片到本地

要用try-catch-finally抛异常，这里为了看起来方便就直接throws了。但这样是不对的
在这里插入图片描述
这里是用了try-catch-finally
在这里插入图片描述
在这里插入图片描述

zxfhahaha
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java网络编程
03-03
在本资料中，《Java网络编程》第三版提供了深入浅出的讲解，旨在帮助开发者提升对这一领域的理解。 1. **基础概念**： - **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络...
Java 网络编程（大全）
热门推荐
快乐学习
09-20 1万+
浏览器就是我们日常使用的浏览器去访问各种网站，只要有浏览器就可以访问，不依赖特定的PC端，在任意设备上都可以访问网站服务器。不需要建立连接（因为把数据源IP、目的地IP、端口封装成数据包），每个数据包在64KB内，只管发，不管对方有没有接到确认什么的。IP地址可以理解为具体哪个计算机，端口理解计算机上的程序（一个程序一个端口），协议理解为电脑通过什么方式和外界交互。客户端是需要程序员去开发的，例如日常使用的各种的APP，服务端就是服务器。一、2请分析C/S和B/S架构相比的各自的优缺点？
Java 网络编程
编程开发相关技术学习
12-06 2409
在计算机网络要做到井井有条的交换数据，就必须遵守一些事先约定好的规则，比如交换数据的格式、是否需要发送一个应答信息。这些规则被称为网络协议。TCP/IP：传输控制/网络协议，是面向连接的协议，发送数据前要先建立连接(发送方和接收方的成对的两个之间必须建 立连接)，TCP提供可靠的服务，也就是说，通过TCP连接传输的数据不会丢失，没有重复，并且按顺序到达。UDP：UDP它是属于TCP/IP协议族中的一种。是无连接的协议，发送数据前不需要建立连接，是没有可靠性的协议。因为不需要建立连接所以可以在在网络上以任何可
Java-网络编程（UDP/TCP）
最新发布
棉花糖老丫
04-20 1256
当一台计算机要与另一台计算机通信时,需要知道另外一台计算机的地址.互联网协议(Internet Protocol ,IP)可以用来唯一的标识互联网上的计算机.IP地址由4段用点隔开的0~255的十进制数组成例如,192.168.10. 2 .计算机上的每一个程序都会对应一个端口号.例如使用计算机可以进行E-Mail(邮件) WWW(浏览器) FTP(文件传输)操作. 这些程序都需要通过互联网进行数据的传输.计算机是通过端口进行的判断数据的归属,不同的程序有不同的端口.通信的两端都有Socket。
Java网络编程
u011005040的博客
11-01 1893
Java网络编程
【Java 基础篇】Java网络编程详解
繁依Fanyi的博客
06-26 2932
本文详细介绍了Java网络编程的概念、原理和常用技术。网络编程是一项重要的技术，在现代互联网时代扮演着重要的角色。通过学习和掌握Java网络编程，开发人员可以构建各种网络应用，实现客户端-服务器通信、分布式系统等功能。希望本文对你理解和应用Java网络编程有所帮助！
网络编程1
as15282235592的博客
07-08 410
网络编程
Java网络编程期末考试复习题库+答案
07-06
Java网络编程是计算机科学中的一个重要领域，特别是在软件开发中，它涉及到如何通过网络进行数据传输和通信。在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这...
Java中的网络编程
weixin_69778508的博客
06-24 1012
网络编程是指使用计算机网络进行软件开发的一种方式。它涉及了利用网络传输数据、进行远程通信和实现分布式计算的技术和方法。在网络编程中，开发人员可以利用各种编程语言和网络协议来实现网络应用程序的设计和开发。以下是网络编程的几个主要概述：客户端-服务器模型：网络编程通常基于客户端-服务器模型。在这种模型中，有一个或多个服务器端应用程序提供服务，而客户端应用程序通过网络连接到服务器，请求服务并接收响应。服务器端负责处理客户端的请求并提供相应的功能。
网络基础知识（华为版）
08-26
这个版本很适应于当前国内市场网络基础现状，实用性好！
Java-网络编程
Ego_Ekko的博客
09-20 1194
1）两台及以上设备之间通过网络实现数据传输；2）将数据通过网络从一台设备传送到另一台设备；3）java.net包下提供了一系列的类或者接口使用来实现网络通信。
Java网络编程详解
张议的博客
01-22 1426
文章目录网络基础知识两台计算机通过网络进行通信![在这里插入图片描述](https://img-blog.csdnimg.cn/20190121193009329.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzkw...
java——网络编程
Why_does_it_work的博客
06-24 4127
它的核心组件包括IoFilter、IoSession、IoHandler等，可以帮助开发人员构建可靠的、高效的网络应用程序。Spring Web是Spring框架中的一个模块，提供了一系列用于构建Web应用程序的工具和框架，包括MVC、REST等。它提供了丰富的API和插件，可以帮助开发人员实现高性能、可靠的Web应用程序。通过这些规则和标准，不同的计算机和设备可以相互通信，并保证数据的正确传输和接收。Java中的NIO编程是一种基于事件驱动的编程模式，相对于传统的IO编程，它具有更高的性能和扩展性。
网络编程
smile radiantly
11-24 771
一:TCP网络编程 1.Socket的TCP编程 Java语言的基于套接字编程分为服务端编程和客户端编程，其通信模型如图所示： 2.客服端Socket的工作过程 创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。创建的同时会自动向服务器方发起连接,若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。 打开连接到 Socket 的输入/ ...
Java网络编程基础
"Fundamental Networking in Java 是一本关于Java网络编程的基础教程，由Esmond Pitt撰写。这本书涵盖了Java网络编程的基本概念和技术，旨在帮助读者理解和掌握如何在Java环境中进行网络通信。作者Esmond Pitt还与...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值