十一、网络编程。TCP\UDP\socket

最新推荐文章于 2024-09-19 15:13:19 发布
最新推荐文章于 2024-09-19 15:13:19 发布
阅读量389 收藏
点赞数
分类专栏： 基础知识 文章标签： socket 网络 java udp
赵鑫阳
本文链接：https://blog.csdn.net/weixin_45948874/article/details/107958453
版权

网络编程

文章目录


1576568236682

ip地址：网络上的唯一标识

ip的组成：32位组成，由4个8位二进制（每一位最大值是255，每一位十进制标识0-255）

192.168.1.100
11000000.10101000.00000001.01100100二级制不容易记忆，改成是十进制

协议：为了让网络中不同计算机之间能够相互通信而简历的规则、标准、约定

TCP协议

面向连接、可靠的（不丢失、不重复、有序）、基于字节流的传输通信协议。(传输速度相对慢)

UDP协议

无连接的协议。在传输数据之前。客户端和服务器之间不建立和维护链接。提供不可靠的数据传输（速度快）

socket(套接字)

基于TCP协议的网络通信，可以提供双向安全的网络通信。

socket需要借助于数据流（字节流）来完成数据的传递工作：重点

1576569161833

  • 发送数据：OutputStream
  • 接收数据：InputStream

TCP案例模板：

1.客户端建立链接、服务端准备服务（ip（可省略）、端口）

本机默认ip：127.0.0.1/localhost

2.通过socket生成InputStream/OutputStream（准备发送数据）

3.使用InputStream/OutputStream进行发送、接收数据

4.关闭InputStream/OutputStream、socket

1576571307737

服务端(ServerSocket)

package demo01;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {

    public static void main(String[] args) {
//        1.准备服务.ip:默认本机127.0.0.1,端口8888
        ServerSocket serverSocket = null ;
        Socket socket = null ;
        InputStream in = null ;
        BufferedReader reader = null ;
        OutputStream out = null ;
        try {
             serverSocket = new ServerSocket(8888) ;
            System.out.println("服务器启动");
            //准备完毕，可以监听客户端请求
             socket = serverSocket.accept();//一直阻塞，直到有客户端连接
            System.out.println("服务端检测到客户端连接成功！");
            

            //  2.通过socket生成inputstream/outputstream（准备发送数据）
             //3.使用inputstream/outputstream进行发送、接受数据
             in = socket.getInputStream();
            //带缓冲区的字符流（字节流-转换流-字符流）
             reader = new BufferedReader(new InputStreamReader(in));
            String info = null ;
            while(  (info=reader.readLine()) != null       ){
            System.out.println("I am server,接受到客户端信息是：" + info);    
            socket.shutdownInput();

            //服务端做出反馈
            out = socket.getOutputStream();
            out.write("welcome  client....".getBytes());
            socket.shutdownOutput();

        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                // 4.关闭inputstream/outputstream、socket
               if(reader !=null) reader.close();
                if(out !=null) out.close();
                if(in !=null) in.close();
                if(socket !=null) socket.close();
                if(serverSocket !=null) serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端(Socket)

package demo01;

import java.io.*;
import java.net.Socket;

/*
 * Created by 颜群
 */
public class MyClient {

    public static void main(String[] args) {
        Socket socket = null ;
        OutputStream out = null ;
        InputStream in = null ;
        BufferedReader reader = null ;
        try {
             socket = new Socket("127.0.0.1",8888);
            System.out.println("客户端链接成功！");
             out = socket.getOutputStream();
            out.write( "hello server".getBytes()  );
            socket.shutdownOutput();

          
            //接收服务端的反馈
             in = socket.getInputStream();
             reader = new BufferedReader(new InputStreamReader(in));
            String info = null;
            while(   (info=reader.readLine()) != null ){
                System.out.println("I am client,接收到的服务端消息："+info);
            }
            socket.shutdownInput();
          
          
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
               if(out!=null) out.close();
                if(in!=null) in.close();
                if(socket!=null) socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

对象流

网络传递一个对象：

1.将要传递的对象序列化 (对象implements Serializable)

2.使用对象流（ObjectInputSream\ObiectOutputStream）

1576632938710

要传递的对象

package Demo02;

import java.io.Serializable;

public class Student implements Serializable {
    private int sid;
    private String name;
    private int age;
    public Student() {
    }
    public Student(int sid, String name, int age) {
        this.sid = sid;
        this.name = name;
        this.age = age;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

服务端

package Demo02;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        ObjectInputStream ois = null;
        try {
            serverSocket = new ServerSocket(8888);
            socket = serverSocket.accept();

            //收客户端发来的对象
            in = socket.getInputStream();
            //包装
            ois = new ObjectInputStream(in);
            try {
                Student student = (Student) ois.readObject();
                System.out.println(student);
                socket.shutdownInput();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }


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

客户端

package Demo02;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

public class MyClient {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream out = null;
        ObjectOutputStream oos = null;
        try {
            socket = new Socket("localhost", 8888);
            Student student = new Student(1001, "zs", 23);
            out = socket.getOutputStream();
            //将输出流编程对象流.装饰模式
            oos = new ObjectOutputStream(out);
            oos.writeObject(student);
            socket.shutdownOutput();


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

处理多用户问题

1576637353440

思路：

客户端：代码不变

服务端：每当有一个客户端，就开启一个新线程去处理（每个线程专门处理一个客户端对象）

1576638316325

要传递的对象

package Demo03;

import java.io.Serializable;

public class Student implements Serializable {
    private int sid;
    private String name;
    private int age;
    public Student() {
    }
    public Student(int sid, String name, int age) {
        this.sid = sid;
        this.name = name;
        this.age = age;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

服务端

package Demo03;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Myserver {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            while(true) {
                Socket socket = serverSocket.accept();
                ServerThread serverThread = new ServerThread(socket);
                serverThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

服务端线程

package Demo03;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ServerThread extends Thread{

        Socket socket ;
        public ServerThread(Socket socket){
            this.socket = socket;
        }
    @Override
    public void run() {
        InputStream  in =null;
        ObjectInputStream ois = null;
        OutputStream out =null;
        //接收客户端数据
        try {
              in = socket.getInputStream();
            //装饰模式
             ois = new ObjectInputStream(in);
            Object  student = (Student)ois.readObject();
            System.out.println(student);
            socket.shutdownInput();

            //返回文字
             out = socket.getOutputStream();
            out.write("已经收到".getBytes());


        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
                ois.close();
                in.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

客户端

package Demo03;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

public class MyClient {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream out = null;
        ObjectOutputStream oos = null;

        try {
            socket = new Socket("localhost", 8888);
            Student student = new Student(1001, "zs", 23);
            out = socket.getOutputStream();
            //将输出流编程对象流.装饰模式
            oos = new ObjectOutputStream(out);
            oos.writeObject(student);
            socket.shutdownOutput();

            InputStream in = socket.getInputStream();
            byte[] buf = new byte[100];
            in.read(buf);
            System.out.println("接收到服务端返葵"+new String(buf));

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

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

UDP案例模板

DatagramPacket（数据）：封装了数据报、数据长度、目标地址和目标端口

DatagramSocket（收发器）：接收和DatapramPacket中封装好的数据

发送

package Demo04;

import java.io.IOException;
import java.net.*;

/*
 * Created by 颜群
 */
public class Send {
    public static void main(String[] args) {
        DatagramSocket ds = null ;
        //创建一个InetAddress对象
        InetAddress ip = null ;
        try {
            ip = InetAddress.getByName("127.0.0.1");
            String msg = "helloserver.." ;
            DatagramPacket dp = new DatagramPacket(msg.getBytes(),msg.length(),ip,9999) ;
            ds = new DatagramSocket() ;
            ds.send(  dp );
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            ds.close();
        }
    }
}

接收

	package Demo04;

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

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

        byte[] data = new byte[64];
        //准备接受数据的对象
        DatagramPacket dp = new DatagramPacket(data, data.length);
        DatagramSocket ds =null;
        //接收数据
        try {
             ds = new DatagramSocket(9999);
            ds.receive(dp);
            //显示接收数据
            String s = new String(dp.getData(),0, data.length);
            System.out.println("接收到的数据"+s);
            System.out.println("显示发送方的信息"+dp.getAddress().getHostAddress());
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            ds.close();
        }
    }
}

总结：发送数据使用的工具

tcp：字节流

udp:DatagramScoket

网络编程中一些工具类

InetAddress

   public static void main(String[] args) {
        InetAddress host = null;
        try {
            //本机
            host = InetAddress.getLocalHost();
            System.out.println(host);
            //网络中任意一台
            InetAddress host163 = InetAddress.getByName("www.163.com");
            System.out.println(host163);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }

1576720208036

URL /URLConnection

1576720826201

以下示例，注意点：输入流 url-内存； 输出流：内存-本地

package demo05;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

/*
 * Created by 颜群
 */
public class URLDemo {
    public static void main(String[] args) {
        InputStream in = null ;
        URLConnection urlConnection = null;
        OutputStream out = null ;
        try {
            URL url = new URL("https://www.163.com/") ;
             urlConnection = url.openConnection();
             in = urlConnection.getInputStream();

             out = new FileOutputStream("d:\\163.txt");
            byte[] buf = new byte[64] ;
            int len = -1 ;
            while(  (len = in.read(buf)) != -1 ){
                out.write(buf,0,len);
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
               if(out!=null) out.close();
               if(in!=null)  in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

​

赵同学‍
关注
专栏目录
赵雅智_java 网络编程（3）之TCP
柠檬不萌
09-12 1175
TCP：客户端服务端 服务端： ServerSocket：编写TCP网络服务程序,首先要用到java.net.ServerSocket类用以创建服务器Socket 构造方法： ServerSocket(int port)：创建绑定到特定端口的服务器套接字ServerSocket(int port, int backlog)：利用指定的backlog(服务器忙时保持连接请求的等待客户数量
欧姆龙TCP UDP Socket网络通讯.zip
11-12
本资源"欧姆龙TCP UDP Socket网络通讯.zip"提供了关于如何利用TCP和UDP协议通过Socket进行欧姆龙PLC设备通信的实例。以下是关于这个主题的详细知识点： 1. **Socket基础**： - Socket是一种网络编程接口，用于在...
TCP/UDP socket工具
04-19
TCP/UDP socket工具
基于Socket的UDP和TCP编程介绍
华清远见 | 程序员的学习天堂
11-30 1908
作者：王珊珊，华清远见嵌入式学院讲师。一、概述TCP（传输控制协议）和UDP（用户数据报协议是网络体系结构TCP/IP模型中传输层一层中的两个不同的通信协议。TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(stream socket)的一种。UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口(da
网络编程：掌握TCP Socket和UDP Socket
最新发布
qq_62859013的博客
09-19 1368
网络编程：掌握TCP Socket和UDP Socket
socket之TCP UDP
leo
05-14 461
编程区别      通常我们在说到网络编程时默认是指TCP编程，即用前面提到的socket函数创建一个socket用于TCP通讯，函数参数我们通常填为SOCK_STREAM。即socket(PF_INET, SOCK_STREAM, 0)，这表示建立一个socket用于流式网络通讯。 　 SOCK_STREAM这种的特点是面向连接的，即每次收发数据之前必须通过connect建立连接，也是双
13、TCP Socket与UDP Socket
单俞浩的博客
05-08 1660
套接字：应用进程与端到端传输协议（TCP或UDP）之间的门户 2种传输层服务的socket类型： （1）TCP：可靠的、字节流的服务 （2）UDP：不可靠的（数据UDP数据报）服务 一、TCP Socket 1、服务器：创建Welcome Socket、捆绑自身IP地址和端口号、等待连接（阻塞状态） 2、客户端：建立Socket、捆绑Socket、连接Socket 3、过程： （1）首先先明白服务器必须先启动，客户机才能请求连接，所以肯定是服务器创建好Socket等待客户机的连接 （2）服务器创建好Welc
UDP-TCP.rar_TCP UDp_TCP-UDP_tcp/udp socket_网络UDP TCP
09-20
标题中的"UDP-TCP.rar"表明这是一个关于网络传输协议UDP（User Datagram Protocol）与TCP（Transmission Control Protocol）的压缩文件，而"...强调了涉及的内容包括TCP与UDP的对比、Socket编程以及在网络层面上的应用...
Linux网络编程之UDP Socket程序示例
12-31
在网络传输协议中，TCP协议提供的是一种可靠的，复杂的，面向连接的数据流（SOCK_STREAM）传输服务，它通过三段式握手过程建立连接。TCP有一种“重传确认”机制，即接收端收到数据后要发出一个肯定确认的信号，发送...
TCP，UDP，Socket，Http网络编程面试题 47道.pdf
03-10
本文档总结了网络编程面试题的关键知识点，涵盖了 TCP、UDP、Socket、Http 等网络协议的基础知识、网络编程的基本概念、网络协议的分层结构等内容。通过阅读本文档，读者可以了解网络编程的基本原理、网络协议的作用...
tcp+udp.rar_TCP/IP_linux udp socket_linux 网络编程_socket linux udp
09-20
描述中提到的"socket网络编程在linux下的实现，支持tcp/udp两种协议"，这表明这个压缩包可能包含了示例代码或教程，教你如何在Linux系统中使用套接字API进行TCP和UDP编程。对于TCP，你可能会学习到如何建立连接、...
WebSocket Socket TCP/UDP
11-24
WebSocket Socket通信源码例子，TCP/UDP都有，适合网络通信入门的练习与学习，有一个在线的聊天室系统
Socket/TCP/UDP
m0_59489141的博客
11-22 322
Socket套接字是网络通信的编程接口，而TCP是一种面向连接的、可靠的传输协议。在使用TCP进行网络通信时，应用程序可以使用Socket套接字来建立连接、发送和接收数据。Socket套接字是实现TCP协议的一种方式。socket可以看作实现网络传输的对象Socket套接字可以用于实现不同的网络协议，包括TCP、UDP等使用创建了一个Socket对象。Socket类通常用于TCP、UDP通信。Socket套接字是用于网络通信的编程接口，它提供了一种机制，使得应用程序能够通过网络进行数据传输。
【linux网络】socket编程(TCP/UDP)
ProcedureStone的博客
04-13 1107
在函数内部，函数会解析local的前2个字节，如果是AF_INET就表示使用IPv4的网络通信，如果AF_UNIX就表示使用本地通信。当客户端调用 socket() 函数创建套接字时，操作系统会为该套接字分配一个未使用的端口号（通常是一个临时端口号），并在后续的通信过程中，该端口号会被动态地绑定到套接字上。连接的可靠性是有代价的，需要维护可靠性，这意味TCP更复杂，而不可靠意味UDP很简单。sin_addr的类型是in_addr的结构体，地址保存在in_addr的成员s_addr中，使用时要注意。
一篇文章看明白 TCP/IP，TCP，UDP，IP，Socket 之间的关系
热门推荐
jeanboy
05-16 5万+
TCP/IP，TCP，UDP，IP，Socket 概述 什么是 TCP/IP？ TCP，UDP 有什么区别？ 什么是 Socket？ 网上这方面的资料有很多，但都很琐碎，没有系统化，要么看完很快就忘记了，要么就是看完迷迷糊糊似懂非懂，下面我们来一一攻破以上问题。 TCP/IP 计算机与网络设备要相互通信，双方就必须基于相同的方法。比如，如何探测到通信目标、由哪一边先发起通信、...
网络编程套接字——Socket(TCP/UDP)
weixin_48796138的博客
04-17 2005
目录🥥 Socket API 🥥 Socket API 网络编程嵌套字就是操作系统给应用程序提供的一组API,嵌套字是通信的基石 socket 译为插座,也可以认为是应用层和传输层之间的桥梁,socket是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。socket允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。 在传输层中有两组重要的协议 ...
socket
liutao2016的博客
11-14 358
网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。 Socket的英文
.NET TCP、UDP、Socket、WebSocket
weixin_40614460的博客
09-13 241
做.NET应用开发肯定会用到网络通信，而进程间通信是客户端开发使用频率较高的场景。 进程间通信方式主要有命名管道、消息队列、共享内存、Socket通信，个人使用最多的是Sokcet相关。 而Socket也有很多使用方式，Socket、WebSocket、TcpClient、UdpClient，是不是很多？HttpClient与TcpClient、WebSocket之间有什么关系？这里我们分别介绍...
socket tcp和udp
一技旁身
10-30 505
1. tcp是一种面向连接的、可靠的、基于字节流的运输层通信协议。用8位字节表示的数据流然后TCP把数据流分割成适当长度的报文段（受到链路层最大传送单元（MTU）的限制）。tcp为了保证不发生丢包，就给每一个字节一个序号，同时序号也保证数据的顺序，然后接手端对成功收到的字节发送一个ack确认；如果在合理的时间内没有发送ack确认信息，那么tcp会将数据重传。tcp会校验数据是否有错。 2. ud...
Socket网络编程实战：TCP/UDP示例代码详解
它覆盖了socket编程的许多关键方面，包括但不限于TCP和UDP协议的使用、IO模式的选择以及高级网络编程技术的应用。此外，该资源的描述提到了专栏链接，这意味着除了代码样本之外，还可能有相关的文章或者教程来引导...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赵同学‍

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值