java Socket笔记

最新推荐文章于 2022-10-13 14:30:27 发布
最新推荐文章于 2022-10-13 14:30:27 发布
阅读量219 收藏
点赞数
文章标签： java socket 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdsg45/article/details/105435191
版权

学习视频：Java Socket应用

网络基础介绍

在这里插入图片描述

TCP/IP协议

  • TCP/IP是目前世界上应用最为广泛的协议
    • 也是TCP和IP为基础的不同层次上多个人协议的集合
    • 也称：TCP/IP协议族或TCP/IP协议栈
  • TCP：Transmission Control Protocol 传输控制协议
  • IP：Internet Protocol 互联网协议

在这里插入图片描述

IP地址

为实现网路不同计算机之间的通信，每台机器都必须有一个唯一的标识----IP地址

在这里插入图片描述

IP地址格式：数字型，如：192.168.0.1 （常见IPv4）

端口

  • 用于区分不同应用程序
  • 端口号范围为065535，其中01023为系统所保留
  • IP地址和端口号组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础
  • HTTP : 80 FTP : 21 telnet : 23

在这里插入图片描述

java中的网络支持

针对网络通信的不同层次，java提供的网络功能有四大类：

  • InetAddress：用于表示网络上的硬件资源。
  • URL：同一资源定位符，通过URL可以直接读取或写入网络上的数据。
  • Sockets：使用TCP协议实现网络通信的Socket相关的类。
  • Datagram：使用UPD协议，将数据保存在数据报中，通过网络进行通信

Java中网络相关API的应用

InetAddress 的应用

InetAddress类用于标识网络上的硬件资源，表示互联网协议（IP）地址。

实例：

public class InetAddressTest {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getLocalHost();
        System.out.println("计算名"+address.getHostName());
        System.out.println("IP地址"+address.getHostAddress());
        byte[] bytes = address.getAddress(); //获取字节数组形式的IP地址
        System.out.println("字节数组形式的IP"+ Arrays.toString(bytes));

        //直接输出InetAddress对象
        System.out.println(address);

        //根据机器名获取InetAddress实例
        InetAddress address2 = InetAddress.getByName("DESKTOP-0BBS5QP");
        System.out.println("IP地址"+address2.getHostAddress());

        //根据ip获取InetAddress实例
        InetAddress address3 = InetAddress.getByName("192.168.111.1");
        System.out.println("计算机名"+address3.getHostName());
    }
}

输出结果：

在这里插入图片描述

URL的应用

1、统一资源定位符URL（Uniform Resource Locator）是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。

2、URL由两部分组成：协议名称和资源名称，中间用冒号隔开。
在这里插入图片描述

3、在java.net包中，提供了URL类来表示

  • 常用方法

    public class URLTest {
    public static void main(String[] args) {
        try {
            //创建一个URL实例
            URL imooc=new URL("http://www.imooc.com");
            //?后面为参数，#后面表示锚点
            URL url = new URL(imooc, "/index.html?username=tom#test");
            System.out.println("协议"+url.getProtocol());
            System.out.println("主机"+url.getHost());
            //如果未指定端口号，则使用默认的端口号，此时getPort()方法返回值为-1
            System.out.println("端口"+url.getPort());
            System.out.println("文件路径"+url.getPath());
            System.out.println("文件名"+url.getFile());
            System.out.println("相对路径"+url.getRef());
            System.out.println("查询字符串"+url.getQuery());
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

使用URL读取网页内容

  • 通过URL对象的openStream()方法可以得到质的资源的输入流。
  • 通过输入流可以读取、访问网络上的数据。
public class URLOpenText {
    public static void main(String[] args) {
        try {
            URL url= new URL("http://www.baidu.com");
            //通过URL的openStream方法获取URL对象表示的资源的字节输入流
            InputStream is = url.openStream();
            //将字节输入流转化为字符输入流
            InputStreamReader isr = new InputStreamReader(is);
            //为字符输入流添加缓冲
            BufferedReader br = new BufferedReader(isr);
            String data = br.readLine();    // 读取数据
            while (data!=null){
                System.out.println(data);
                data=br.readLine();
            }
            br.close();
            isr.close();
            is.close();
        }  catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Sccket实现TCP编程

Socket通信

TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据基于TCP协议实现网络通信的类

  • 客户端的Socket类
  • 服务器端的ServerSocket类

Sokoet通信模型

在这里插入图片描述

Socket通信实现步骤

1、创建ServerSocket和Soket

2、打开连接到Socket的输入/输出流

3、按照协议对Socket进行读/写操作

4、关闭输入输出流、关闭Socket

案例：用户登录

服务器端：

  • 创建ServerSocket对象，绑定监听端口
  • 通过accept()方法监听客户端请求
  • 连接请求后，通过输入流读取客户端发送的请求信息
  • 通过输出流向客户端发送响应信息
  • 关闭相关资源
public class Server {
    public static void main(String[] args) {
        try {
            //1、创建一个服务器端Socket，指定绑定的端口，并监听
            ServerSocket serverSocket = new ServerSocket(8888);
            //2、调用accept（）方法开始监听，等待的连接
            System.out.println("***服务器即将启动，等待客户端的连接***");
            Socket socket = serverSocket.accept();
            //3、获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();  //字节输入流
            InputStreamReader isr = new InputStreamReader(is);  //将字节流转化为字符流
            BufferedReader br = new BufferedReader(isr);
            String info =null;
            //循环读取客户端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4、获取输出流，响应客户端的请求
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);
            pw.write("欢迎您！詹大帅哥");
            pw.flush();//调用flush()方法将缓冲输出
            //5、关闭资源
            pw.close();
            os.close();
            br.close();
            isr.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：

  • 创建Socket的对象，指明需要连接的服务器的地址和端口号
  • 连接建立后，通过输出流向服务器端发送请求信息
  • 通过输入流获取服务器响应的信息
  • 关闭相关资源
public class Client {
    public static void main(String[] args) {
        //1、创建客户端Socket，指定服务器地址和端口
        try {
            Socket socket = new Socket("localhost", 8888);
            //2、获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();//字节输出流
            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：admit；密码:123");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3、获取输入流
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info=null;
            //循环读取服务端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是客户端，服务器说："+info);
            }
            is.close();
            br.close();
            pw.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程实现多客户的通信

多线程服务器

  • 服务器端创建ServerSocket，循环调用accept()等待客户端连接
  • 客户端创建一个Socket并请求和服务器连接
  • 服务器端接受客户端请求，创建Socket与该客户建立专线连接
  • 建立连接的两个Socket在一个单独的线程上对话
  • 服务器端继续等待新的连接
public class SerberThread extends Thread {
    // 和本线程相关的Socket
    Socket socket=null;

    public SerberThread(Socket socket){
        this.socket=socket;
    }
    //线程执行的操作，响应客户端的请求

    public void run(){
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            //字节输入流
            is = socket.getInputStream();
              //将字节流转化为字符流
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info =null;
            //循环读取客户端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4、获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("欢迎您！詹大帅哥");
            pw.flush();//调用flush()方法将缓冲输出
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5、关闭资源
            try {
                if (pw !=null)
                pw.close();
                if (os !=null) {
                    os.close();
                if (br !=null)
                    br.close();
                if (isr !=null)
                    isr.close();
                if (is !=null)
                    is.close();
            }
        } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

修改Server类

public class Server {
    public static void main(String[] args) {
        try {
            int count=0; //记录客户端数量
            //1、创建一个服务器端Socket，指定绑定的端口，并监听
            ServerSocket serverSocket = new ServerSocket(8888);
            //2、调用accept（）方法开始监听，等待的连接
            System.out.println("***服务器即将启动，等待客户端的连接***");
            Socket socket =null;
            while (true){
                //调用accept（）方法开始监听，等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新的线程
                SerberThread serberThread = new SerberThread(socket);
                //启动线程
                serberThread.start();
                count++;
                System.out.println("客户端的数量："+count);
                InetAddress address = socket.getInetAddress();
                System.out.println("IP地址："+address);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述

Sccket实现UDP编程

  • UDP协议（用户数据报协议）是无连接、不可靠的、无序的
  • UDP协议以数据报作为数据传输的载体
  • 进行数据传输是，首先需要将传输的数据定义成数据报（Datagram），在数据报中指明数据所要达到的Socket（主机地址和端口号），然后再讲数据报发送出去

相关操作类：

  • DatagramPacket：表示数据报包
  • DatagramSocket：进行端到端通信的类

服务器端实现步骤

1、创建DategramSocket，指定端口号

2、创建DatagramPacket

3、接受客户端发送的数据信息

4、读取数据

public class UDPServer {
    public static void main(String[] args) {

        try {
            //1、创建服务器端DategramSocket，指定端口号
            DatagramSocket socket = new DatagramSocket(8800);
            //2、创建DatagramPacket数据报，接收数据
            byte[] data = new byte[1024];
            DatagramPacket packet = new DatagramPacket(data, data.length);
            //3、接受客户端发送的数据信息
            System.out.println("***服务器端已经启动，等待客户端发送数据***");
            socket.receive(packet);
            //4\读取数据
            String info = new String(data,0,packet.getLength());
            System.out.println("我是服务器，客户端所："+info);

            /*
            * 向客户端响应数据
            * */
            //1、定义客户端的地址、端口号、数据
            InetAddress address = packet.getAddress();
            int port=packet.getPort();
            byte[] data2="欢迎您！".getBytes();
            //2、创建数据报，包含响应的信息
            DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
            //3、响应客户端
            socket.send(packet2);
            //4、关闭资源
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端实现步骤

1、定义发送信息

2、创建DatagramPacket，包含将要发送的信息

3、创建DategramSocket

4、发送数据

public class UDPClient {
    public static void main(String[] args) throws IOException {
       // 1、定义发送信息
        InetAddress address = InetAddress.getByName("localhost");
        int prot=8800;
        byte[] data="用户名：shui；密码：123".getBytes();
        // 2、创建DatagramPacket，包含将要发送的信息
        DatagramPacket packet = new DatagramPacket(data, data.length, address, prot);
        // 3、创建DategramSocket
        DatagramSocket socket = new DatagramSocket();
        // 4、发送数据
        socket.send(packet);

        /*
        * 接收服务器响应的数据
        * */
        byte[] data2 = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
        //2、接收服务器响应的数据
        socket.receive(packet2);
        //3、读取数据
        String reply = new String(data2, 0, packet2.getLength());
        System.out.println("我是客户端，服务器说："+reply);
        //4、关闭资源
        socket.close();

    }
}
?Handsome?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TCP聊天室:一个acceptor线程,多个工作线程
qq_40115163的博客
04-19 2471
一.简介 该聊天室相对于之前的聊天室进行了相应的升级: 之前的聊天室进程中只有一个线程,因此该聊天室程序对于监听描述符上的连接请求以及多个聊天室成员的连接描述符上的读写操作只能完成一个; 该聊天室进程中采取了多线程模式,类似于线程池的思想,一个聊天室进程中可以并发的利用主线程处理监听描述符上的连接请求,同时对于每一个聊天室成员的连接描述符分配一个工作线程,完成与该聊天室成员的读写操作. 具体的思想是(创建多个线程,每个线程运行一个独立的...
JAVA Socket编程简单笔记
qq_40692756的博客
09-09 225
TCP连接建立过程： 发送端： 1.确定目的ip与端口： InetAddress serverIP = InetAddress.getByName("127.0.0.1"); int port = 31233; 2．创建套接字： Socket socket=new Socker(serverIP,port); 3．获得输出流： outputStream = socket.getOutputStream(); 4．向流进行写入操作 例如写入一句话： outputStream.write(“一句话”.ge
简单的并发服务器（多个线程各自accept）
chenrang1850的博客
08-13 328
基于之前讲述的简单循环服务器，做一个多个线程各自accept的服务器demo 由于多个线程各自accept，容易造成数据错误，需要在accept前后枷锁 先看下客户端 客户端创建socket，初始化服务器地址信息，然后进行连接 连接成功后发送信息给服务器，并且接受服务器回传的...
网络编程（1）——accept实现多并发及相关细节问题
weixin_42034081的博客
03-16 756
两种解决方式： 1。下面展示一些 多线程实现。 // An highlighted block 父进程：调用accept，回收子进程，利用信号的机制 子进程：处理连接，收发数据 流程： 1.创建socket，得到监听文件描述符lfd————socket 2.将lfd和ip和端口绑定，————bind 3.设置监听————listen 4.进入while(1) { 阻塞等待新的连接到，得到cfd————accept //考虑异常打断,过滤errno中
Java NIO ：如何为通道注册多个事件及多线程处理 Accept 请求
本博客纯属个人网络笔记，如对阁下有用，甚喜；否则，关掉即可，不喜勿喷。专心写代码，不做键盘侠！
08-15 1008
上周梳理了一下 IO 的发展过程，从 BIO 、NIO 到 多路复用，每一个 IO 模型背后的 Java 应用是怎么样的呢？本文记录 NIO 的入门案例，巩固一下 Java NIO 编码知识。的 isValid 状态的实时性。
Socket通信-accept+多线程
热门推荐
微不足道
12-03 1万+
偶然的机会，重新写了一下windows下socket通信的比较基础的代码，太久没有接触socket以及多线程，查了不少博客，但是发现大部分内容比较陈旧，所以决定写一篇博客，顺便自己总结一下。 内容简介 网络通信基本函数介绍 C++11多线程简介 socket通信tcp版本 socket通信udp版本 网络通信基本函数介绍tcp连接模式下客户端流程1.创建socket（套接字） socket(
java socket
人有匪气，代码才能飞起
08-21 320
SOCKET 解决问题 ： 客户端 到 服务端 进行通信（TCP/IP 协议） 客户端 ： java.net.Socket client = new Socket("127.0.0.1",80) ; 创建一个链接 IP 127.0.0.1 ，端口号80 的请求链接（底层已经调用connect() ）。 服务端 ： java.net.ServeSocket serve = new ServeSocket(80) ; 创建一个监听80端口的本地服务（ 已经调用blind() ）。 客户端与服务端有了
Java Socket编程笔记_动力节点Java学院整理
08-30
Java Socket编程笔记 Java Socket编程是Java语言中用于网络编程的重要组件之一。它允许开发者创建客户端-服务器架构的应用程序，通过Socket和ServerSocket来实现网络通信。本笔记记录了Java Socket编程的主要方面，...
学习笔记：多线程Java Socket编程示例
最新发布
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
java全套笔记 来自狂神说java笔录.zip
12-28
【Java编程语言基础】 Java是一种广泛使用的面向对象的编程...这些笔记内容全面覆盖了Java的基础和进阶知识，适合从零开始学习Java的人群，通过系统学习，可以建立起扎实的Java编程基础，为实战项目开发打下坚实基础。
[Java]详解Socket和ServerSocket学习笔记
09-15
Socket和ServerSocket是Java中实现网络通信的核心组件，它们提供了基于TCP/IP协议的低级通信接口。在HTTP协议无法满足实时性要求的应用场景，如即时通讯、在线游戏等，Socket成为了首选。本篇将深入讲解Socket和...
accept与select在多线程环境中的行为
weixin_43698578的博客
10-13 618
accept与select的线程安全性
linux 多线程或多进程 epoll处理 accept 惊群问题
Linux高级开发的博客
02-21 3038
什么是惊群 简单说，惊群是因为多进程（多线程）在同时阻塞等待同一个事件的时候（休眠状态），当时间发生时，就会唤醒所有等待的（休眠的）进程（线程）。但是事件只能被一个进程或线程处理，而其他进程（线程）获取失败，只能重新进入休眠状态，这种现象和性能浪费就叫做惊群。 产生惊群的条件 多个进程或者多个线程 同时等待处理一个事件 具体场景复现 测试环境 : debian11 内核5.10.0-8 编译器 clang11 多线程和多进程在惊群问题上差不多，为了少些一点，下文中没有特殊说明，多线程 也包含
多进程与多线程实现高性能服务器
qx04070711的博客
05-07 124
之前的TCP编程只能完成服务器与客户端一对一的交互，也就是说服务器只能串行的为一个客户端服务，效率太低，因此为了改善这种情况，提出了多进程和多线程实现高性能的服务器。 多进程 在之前TCP编程的基础上调用了fork函数； 由父进程来进行与客户端的连接实现accept； 由子进程与一个客户端交互实现recv()/加粗样式send()。 需要注意的问题： 1、accept的返回值C，也就是新生...
socket accept()多线程连接 详解
薛瑄的博客
11-07 1万+
socket协议详解：https://software.intel.com/zh-cn/blogs/2012/12/18/java-socket-socket在使用accept函数的时候，如果服务器面向多个客户的连接， 必须使用while循环，每次循环阻塞在accept函数，等待新的连接到来，这样才能返回新的socket。如果不使用while死循环每次阻塞在accept函数，也可以面向多个客户连接，
Linux网络（七）—— 线程池accept处理高并发connect
qq_41033011的博客
08-17 1689
前言 服务器再调用listen 和 accept后，就会阻塞在accept函数上，accept函数返回后循环调用accept函数等待客户端的TCP连接。 我们知道服务器端listen套接字能处理的连接数与监听队列的大小有关，如果这时候有大量的用户同时发起connect连接，那么在listen有队列上限（最大可接受TCP的连接数）的情况下，有多少个connect会成功。 实验证明，当连接数远远高于listen的可连接数上限时，客户端的大部分TCP请求会被抛弃，只有当listen监听队列空闲或者放弃某个连接时，
学习笔记：多线程Java Socket编程及线程池实现
本学习笔记通过一个多线程 Java Socket 编程示例来展示如何使用 Java 的 ExecutorService 来实现线程池的方式，从而模拟客户端多用户向同一服务器端发送请求的情况。首先，通过在服务端编写一个 MultiThreadServer ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值