JavaSE进阶——Day14——网络编程

最新推荐文章于 2024-07-05 17:01:51 发布
最新推荐文章于 2024-07-05 17:01:51 发布
阅读量104 收藏
点赞数
分类专栏： JavaSE 文章标签： tcp/ip java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyl_010825/article/details/130016338
版权

1、服务器介绍

  • 服务器就是一台配置很高的电脑

  • 服务器常见的场景

    • 通过网址访问网站

    • 登陆

    • 注册

    • 外卖软件

    • 打车软件

    • ...

    • 只要涉及到网络的操作, 都需要连接服务器

2、互联网架构分类

BS架构 ：

  • Browser / Server

优点：不需要下载客户端，使用起来非常方便。

缺点：用户体验比较差

CS架构 ：

  • Client / Server

缺点：需要下载客户端，而且每一次要更新内容的时候，都要更新客户端，甚至要重新下载，非常麻烦。

优点：画面非常精美，用户体验比较好。

3、网络编程三要素

1）IP地址

设备在网络中的唯一标识

2）端口

程序在设备中的唯一标识

3）协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有 UDP协议 和 TCP协议

 

4、IP地址

IP（Internet Protocol）：全称 【互联网协议地址】，是分配给上网设备的唯一标志。

  • 常见的IP分类为：IPv4 和 IPv6

IPV4 :

 

IPV6 :

 

IP的分类

 

5、InetAddress

常用方法：

getByName ：确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址

getHostName：获取主机名

getHostAddress ：获取IP

//1.获取一个IP地址(在网络中计算机的对象)
InetAddress address = InetAddress.getByName("127.0.0.1");
​
//2.获取主机名获取ip地址
//细节：如果能获取到主机名返回的就是主机名
//但是如果有的情况下，获取不到，返回的就是ip地址
String hostName = address.getHostName();
System.out.println(hostName);
​
//3.获取IP
String ip = address.getHostAddress();
System.out.println(ip);

6、端口号

  • 端口：应用程序在设备中唯一的标识。

  • 端口号：用两个字节表示的整数，它的取值范围是0~65535。

    其中0~1023之间的端口号用于一些知名的网络服务或者应用。

    我们自己使用1024以上的端口号就可以了。

    • 常见的端口号

      • 8080 ：tomcat 服务器

      • 3306 ：MySQL 数据库

  • 注意：写代码的时候, 注意端口绑定, 不要出现端口冲突

7、UDP协议和TCP协议介绍

UDP :

  • 用户数据报协议(User Datagram Protocol)

  • UDP是面向无连接通信协议。

速度快，有大小限制一次最多发送64K，数据不安全，易丢失数据

TCP :

  • 传输控制协议TCP(Transmission Control Protocol)

  • TCP协议是面向连接的通信协议。

    速度慢，没有大小限制，数据安全

8、UDP协议收发数据

发送数据

  1. 创建发送端对象 : DatagramSocket ds = new DatagramSocket();

  2. 创建数据包 : DatagramPacket dp = new DatagramPacket(字节数组, 数据个数, 接收端IP, 接收端端口);

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

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

package com.itheima.udp;
​
import java.net.*;
​
public class Client {
    /*
        DatagramPacket(byte[] buf, int length, InetAddress address, int port)
​
                    参数1: 将传输的数据, 转换为字节, 并存入一个数组
                    参数2: 数组的长度
                    参数3: InetAddress(IP对象)
                    参数4: 端口号
     */
    public static void main(String[] args) throws Exception {
        // 1. 创建DatagramSocket对象 (码头)
        DatagramSocket socket = new DatagramSocket();
​
        // 2. 创建DatagramPacket对象 (包裹对象)
        String content = "你可能说不出哪里好";
        byte[] bytes = content.getBytes();
​
        DatagramPacket packet =
                new DatagramPacket
                        (bytes, bytes.length,
                                InetAddress.getByName("127.0.0.1"),
                                8888);
​
        // 3. 调用码头对象的发送方法, 将包裹对象发送出去
        socket.send(packet);
​
        // 4. 关闭流释放资源
        socket.close();
    }
}

接收数据

  1. 创建接收端对象 : DatagramSocket ds = new DatagramSocket(端口);

  2. 创建数据包 : DatagramPacket dp = new DatagramPacket(字节数组, 数组的长度);

  3. 接收数据 : ds.receive(dp);

  4. 使用接收的数据 : System.out.println(new String(bys, 0, dp.getLength()));

  5. 释放资源 : ds.close();

package com.itheima.udp;
​
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
​
public class Server {
    public static void main(String[] args) throws IOException {
        // 1. 创建DatagramSocket对象(码头), 绑定端口为8888
        DatagramSocket socket = new DatagramSocket(8888);
        // 2. 创建DatagramPacket对象(包裹对象)
        byte[] bys = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bys, bys.length);
        // 3. 调用码头对象的接受方法, 将数据, 接收到自己的包裹当中
        socket.receive(packet);
​
        System.out.println(packet.getAddress());
​
        String s = new String(bys, 0, packet.getLength());
        System.out.println(s);
​
        // 4. 关闭流释放资源
        socket.close();
    }
}

练习

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

发送数据

package com.lyl.net;
​
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
​
public class Client {
    /*
    客户端发送数据
     */
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象，随机绑定端口
        DatagramSocket socket = new DatagramSocket();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要发送的数据:");
        while (true){
            String msg = sc.nextLine();
            if ("886".equals(msg)){
                socket.close();
                break;
            }
            //准备要发送的数据字节数组
            byte[] bytes = msg.getBytes();
            //数据打包
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("192.168.15.49"), 8888);
            //发送
            socket.send(packet);
        }
    }
}

接收数据

package com.lyl.net;
​
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
​
public class Server {
    /*
    服务端接收数据
     */
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象，绑定8888端口
        DatagramSocket socket = new DatagramSocket(8888);
        //创建包
        while (true) {
            byte[] bytes = new byte[1024];
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
            //接受
            socket.receive(packet);
            //从包裹中取出数据
            byte[] data = packet.getData();
            String msg = new String(data,0, packet.getLength());
            //打印数据
            System.out.println(msg);
        }
​
    }
}

操作细节：

需要把发送端运行多次。

IDEA 默认只能运行一次，所以需要进行配置。

需要保证第一个红色箭头是当前要运行多次的类，再点击下面的Edit Configurations，再按照下面的图解进行设置即可。

 

 

9、TCP协议收发数据

  • Java中的TCP通信

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

Java为客户端制提供了Socket类，为服务器端提供了ServerSocket类

构造方法

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

相关方法

方法名说明
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());
​
        //释放资源
        os.close();
        s.close();
    }
}

构造方法

方法名说明
ServletSocket(int port)创建绑定到指定端口的服务器套接字

相关方法

方法名说明
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();
    }
}

注意事项

  1. accept方法是阻塞的,作用就是等待客户端连接

  2. 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接

  3. 针对客户端来讲,是往外写的,所以是输出流；针对服务器来讲,是往里读的,所以是输入流

  4. read方法也是阻塞的

  5. 客户端在关流的时候,还多了一个往服务器写结束标记的动作

  6. 最后一步断开连接,通过四次挥手协议保证连接终止

三次握手和四次挥手

  • UDP : 面向无连接, 数据不安全, 速度快

    • 有传输大小限制 , 一次最多只能发送64k

  • TCP : 面向连接, 数据安全, 速度相对来说较慢

    • 没有传输大小限制

  • 三次握手

 

  • 四次挥手

 

案例—文件上传

  • 客户端代码

package com.lyl.file_tcp;
​
import java.io.*;
import java.net.Socket;
​
public class Client {
    public static void main(String[] args) throws IOException {
        System.out.println("开始连接服务器...");
        //创建对象，参数一为目标IP,参数二为目标端口
        Socket socket = new Socket("127.0.0.1", 9988);
        System.out.println("连接成功...");
        //创建网络流对象
        InputStream is = socket.getInputStream();
        OutputStream os = socket.getOutputStream();
​
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
​
        //将要上传的文件封装为file对象
        File file = new File("D:\\test.png");
        //将文件名写入到服务器
        bw.write(file.getName());
        bw.newLine();
        bw.flush();
​
        //读取服务器上传信号
        String state = br.readLine();
        if ("同意上传".equals(state)) {
            //创建本地输入流，读取文件
            FileInputStream fis = new FileInputStream(file);
            byte[] bytes = new byte[8192];
            int len;
            while ((len = fis.read(bytes)) != -1) {
                //写入网络流
                os.write(bytes,0,len);
            }
            //读取本地文件完毕，关闭输入流
            fis.close();
​
            //给服务器一个结束标记，结束传输
            socket.shutdownOutput();
​
            //读取上传结果
            String result = br.readLine();
            System.out.println(result);
        }
        //关流
        socket.close();
        bw.close();
        br.close();
    }
}

  • 服务器端代码

package com.lyl.file_tcp;
​
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
​
public class Server {
    public static void main(String[] args) throws IOException {
        //创建对象，绑定端口号
        ServerSocket server = new ServerSocket(9988);
        System.out.println("服务器启动...等待客户端连接...");
​
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                1,5,10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
​
        while (true) {
            //接收客户端
            Socket socket = server.accept();
            //将任务提交到线程池
            threadPoolExecutor.submit(new SubmitFileTask(socket));
        }
    }
}

  • SubmitFileTask任务处理类

package com.lyl.file_tcp;
​
import java.io.*;
import java.net.Socket;
import java.util.UUID;
​
public class SubmitFileTask implements Runnable{
    private Socket socket;
​
    public SubmitFileTask(Socket socket) {
        this.socket = socket;
    }
​
    @Override
    public void run() {
        //创建网络流对象
        try {
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
​
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
​
​
            System.out.println("响应客户端请求成功...");
            //读取客户端发来的文件名
            String fileName = br.readLine();
            //获取客户端IP
            String hostAddress = socket.getInetAddress().getHostAddress();
            //以客户端IP创建文件夹
            File floder = new File("E:\\"+hostAddress+"\\");
            floder.mkdirs();
            //创建file对象
            //创建UUID对象调用方法加随机ID，防止文件覆盖
            File file = new File(floder,UUID.randomUUID().toString()+fileName);
            //给出同意上传信号
            bw.write("同意上传");
            bw.newLine();
            bw.flush();
​
            //写出客户端发来的文件到本地
            FileOutputStream fos = new FileOutputStream(file);
            byte[] bytes = new byte[8192];
            int len;
            while ((len = is.read(bytes))!=-1){
                fos.write(bytes,0,len);
            }
            System.out.println("下载成功...");
            //关闭输出流
            fos.close();
​
            //响应给客户端上传结果
            bw.write("上传成功！");
            bw.newLine();
            bw.flush();
​
            //关流
            socket.close();
            bw.close();
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

安生°
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE进阶_学生管理系统
03-12
总的来说，学生管理系统是一个很好的JavaSE进阶实践项目，它涵盖了面向对象编程、集合框架、I/O操作、数据库连接和GUI设计等多个重要知识点。通过这个项目，初学者不仅能巩固基础，还能提升实际编程能力，为后续的...
JavaSE实战——客户端上传文件到服务端
05-05
在JavaSE实战项目中，客户端上传文件到服务端是一个常见的任务，这涉及到Java网络编程、文件操作以及TCP协议的理解和应用。在这个过程中，开发者需要掌握以下几个核心知识点： 1. **Java网络编程基础**：Java提供了...
JavaSE进阶——day02
lyl_010825的博客
03-21 73
抽象类；接口；多态；模板设计模式
黑马程序员——javase进阶——day12——网络编程
qq_56444564的博客
03-22 884
在网络通信协议下，不同计算机上运行的程序，可以进行数据传输单元测试就是编写测试代码，可以准确、快速地保证程序的正确性，Junit是Java单元测试的框架。JUnit4可以通过注解的方式来标记方法 , 让方法存某种意义 ，常见的注解有：@BeforeClass 全局只会执行一次，而且是第一个运行（标记的方法需要是一个静态无参无返回值方法）@Before 在测试方法运行之前运行（非静态无参无返回值方法）@Test 测试方法（此方法必须是非静态无参无返回值方法）, 主要用于测试的方法。
黑马程序员——javase进阶——day13——黑马云盘
qq_56444564的博客
03-22 644
协议就是客户端和服务端通讯双方共同遵守的规定。TCP协议是区分客户端服务端的一个比较底层的协议，传输的数据是字节码数据，如下当客户端连接服务端后，若要上传一个文件到服务端。直接将文件数据传给服务端，那么服务端该如何识别这个数据呢。对于服务端来讲收到的都是字节数据，服务端该如何识别客户端的操作意图，如果是上传文件，那么文件的类型是什么，文件的名字是什么等等信息。怎样让双方在沟通时理解对方的信息呢？我们可以把要发送给对方的数据前加一行描述信息，我们可以称为头信息。
JavaSE进阶——Day11
lyl_010825的博客
04-03 178
1-IO流字符流； 2-转换流； 3-序列化流（对象流）； 4-打印流 ； 5-Properties-重点
JavaSE进阶——Day12——多线程
lyl_010825的博客
04-05 127
1.1-进程（Process）；1.2-线程（Thread）；2-Java中线程的实现方式； 2.4-三种实现方式的对比 ； 3-线程中的相关方法 ；3.2-线程休眠 ；优先级相关方法 ；同步代码块解决数据安全问题 ； 同步方法解决数据安全问题 ； Lock锁 ； 死锁 ； 5-线程的等待唤醒机制 ；生产者和消费者模式
黑马程序员——javase进阶——day05——泛型,数据结构,List,Set集合
qq_56444564的博客
03-07 775
泛型是一种类型参数，专门用来保存类型用的最早接触泛型是在ArrayList，这个E就是所谓的泛型了。使用ArrayList时，只要给E指定某一个类型，里面所有用到泛型的地方都会被指定对应的类型当一个类定义其属性的时候，不确定具体是什么类型时，就可以使用泛型表示该属性的类型定义的格式在类型名后面加上一对尖括号，里面定义泛型。一般使用一个英文大写字母表示，如果有多个泛型使用逗号分隔public class 类名{ ... }举例 :X xObj;泛型的确定。
黑马程序员——javase进阶——day08——异常,多线程,Lambda,Stream,File,递归
qq_56444564的博客
03-17 923
异常就是程序出现了不正常情况 , 程序在执行过程中 , 数据导致程序不正常 , 最终导致了JVM的非正常停止注意 : 语句错误不算在异常体系中当JDK中的异常类型，不满足实际的业务需要时。就可以自己定义异常。例如，学生的年龄数据，如果是负数或者数据 超过了150认为是不合法的，就需要抛出异常。JDK中就没有表示年龄的异常，就需要自己定义异常了如果要自定义编译时异常，就继承Exception如果要自定义运行时异常，就继承RuntimeException是指从软件或者硬件上实现多个线程并发执行的技术。
JavaSE进阶day01————知识回顾
m0_58583618的博客
10-12 214
面向对象特征 类中有且仅有五大成分 面向对象的三大特征: 封装，继承，多态 封装的规范
JavaSE进阶（Day7~Day8）
大小曲奇的博客
10-31 545
就是在一个类中定义一个类。举例：在一个A类的内部定义一个B类， B类就被称为内部类；内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象API应用程序接口简单来说：就是Java帮我们已经写好的一些方法，我们直接拿过来用就可以了。Math 包含执行基本数字运算的方法；没有构造方法，如何使用类中的成员呢？看类的成员是否都是静态的，如果是，通过类名就可以直接调用；Math 类的常用方法。
JavaSE教程——布小禅.docx
09-18
JavaSE教程——布小禅.docx，专门为零基础人设计的教程
JavaSE进阶-03-常用类.pdf
09-10
2020动力节点老杜javaSE进阶班-常用类03教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
dljd javaSE进阶教材
03-28
dljd javaSE进阶教材
网安小贴士（6）TCP/IP分层
m0_73399576的博客
07-03 1096
网安必备贴士栈——TCP/IP分层篇
Keepalived+HAProxy 集群及虚IP切换实践
最新发布
茂盛博客
07-05 850
Keepalived的作用是检测服务器的状态，如果有一台web服务器宕机，或工作出现故障，Keepalived将检测到，并将有故障的服务器从系统中剔除，同时使用其他服务器代替该服务器的工作，当服务器工作正常后Keepalived自动将服务器加入到服务器群中，这些工作全部自动完成，不需要人工干涉，需要人工做的只是修复故障的服务器。对于实现VIP漂移，常见的工具有keepalived，他提供了一系列用于自动检测和控制VIP的功能，通过心跳检测、状态切换等机制，实现Linux集群中VIP的漂移。
linux固定主机ip
syyangg的博客
07-05 1712
linux
firewalld(6)自定义services、ipset
Monster✺◟(∗❛ัᴗ❛ั∗)◞✺的博客
07-02 994
自定义服务配置文件：通常位于目录下，文件名以.xml结尾。这些文件允许用户定义自己的服务，包括其使用的端口、协议、模块（如内核模块）以及目标地址等。系统级服务配置文件：位于目录下，这些文件包含预定义的服务配置，这些服务通常是众所周知的网络服务（如HTTP、SSH等）。参考 /usr/lib/firewalld/services/ssh.xml，在下面新建你需要的服务名以.xml结尾，内容格式参照如ssh.xml、rdp.xml等文件中的内容即可。
JavaSE进阶-09-注解1
08-03
"JavaSE进阶课程关于注解的讲解" 在Java编程中，注解（Annotation）是一种元数据，它可以提供额外的信息给编译器、IDE或其他工具，以帮助处理代码。注解并不直接影响程序的运行，但它们可以用于生成文档、进行代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值