socket编程

最新推荐文章于 2023-07-13 15:31:41 发布

ThetaQing

最新推荐文章于 2023-07-13 15:31:41 发布

阅读量171

点赞数 1

分类专栏： JAVA

本文链接：https://blog.csdn.net/Thera_qing/article/details/113712607

版权

JAVA 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

文章目录

网络编程

网络编程

1 基本知识

1.1 概述

计算机网络：利用通信线路和通信设备，将地理位置不同的、功能独立的多台计算机互连起来，以功能完善的网络软件来实现资源共享和信息传递，
就构成了计算机网络系统。
网络编程的目的：传播交流信息，数据交换，通信
想要达到这个目的需要什么：
1、如何准确地定位网络上地一台主机 192.168.16.124：端口，定位到该计算机上的某个资源；
2、找到了这个主机，如何传输数据呢？传输介质

1.2 网络通信的要素

如何实现网络的通信：
通信双方的地址：ip+端口号
规则

1.3 小结

1、网络编程中的两个主要问题
如何准确定位到网络上的一台或多台主机；
找到主机之后如何进行通信。
2、网络编程中的要素
IP和端口号；IP类
网络通信协议。TCP类、UDP类
3、socket：套接字，即两台机器之间通讯的端点。
4、万物皆对象

2 实际应用

2.1 IP

ip地址类：InetAddress

唯一定位一台网络上计算机；
127.0.0.1：本机localhost
ip地址的分类
- ipv4/ipv6
  - IPV4 127.0.0.1，由4个字节组成，每个字节0~255，共42亿；30亿在北美，4亿在亚洲，2011年用尽；
  - IPV6 128位。8个无符号整数
- 公网（互联网）-私网（局域网）
  - ABCD类地址
  - 192.168.xx.xx，专门给组织内部使用的
域名
记忆IP问题
inetAddress类

2.2 端口

端口表示计算机上的一个程序的进程；

不同的进程有不同的端口好，用来区分软件；
被规定0~65535
被分为TCP、UDP，所以一共有65535*2 单个协议下端口号不能冲突，不同协议可以相同；

端口分类

公有端口0~1023
- HTTP：80
- HTTPS：443
- FTP：21
- Telent：23
程序注册端口：1024~49151，分配用户或者程序
- Tomcat：8080
- MySQL：3306
- Oracle：1521

动态、私有：49152~65535

  netstat -ano  # 查看所有的端口  
  netstat -ano|findstr "1080"  # 查看指定的端口号
  tasklist|findstr "1128"  # 查看指定端口的进程  
  Ctrl+Shift+Esc 快速打开任务管理器

inetSocketAddress类

2.3 通信协议

协议：约定。
网络通信协议：速率、传输码率、代码结构、传输控制……
问题解决：分层
TCP/IP协议簇：实际上是一组协议
重要的两个协议：（传输层）

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

著名协议：

TCP协议
IP：网络互连协议

TCP UDP对比
TCP：打电话

连接：稳定

三次握手、四次挥手

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

四次挥手：ABBA
A：我要走了  
B：你真的要走了吗
B: 你真的真的要走了吗？
A: 我真的要走了！

客户端、服务端有明确的界限
传输完成、释放连接、效率低

UDP：发短信

不连接，不稳定
客户端、服务器没有明确的界限
不管有没有准备好，都可以发给你
导弹
DDOS：洪水攻击，（饱和攻击）

2.4 TCP

客户端
1、通过socket连接服务器；
2、发送消息getOutPutStream。

package socket.TCP;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
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");
            int port = 9999;

            // 2、创建一个socket连接
            socket = new Socket(serverIP,port);

            // 3、发送消息  IO 流
            os = socket.getOutputStream();
            os.write("hello,welcome to class".getBytes());

            // 关闭资源
            os.close();
            socket.close();


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        //todo:关闭资源
        }

    }
}

服务器
1、建立服务的端口ServeSocket；
2、等待客户端连接accept；
3、读取客户端消息getInputStream。

package socket.TCP;

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

// 服务端
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);

            while(true){  // 循环监听
                // 2. 等待客户端连接过来
                socket = serverSocket.accept();  // 监听，一旦监听到就是来自客户端的socket

                // 3、读取客户端的消息
                is = socket.getInputStream();
                // 管道流,通过管道流将两节包裹起来，如果直接用string去写入的话，一旦出现中文就有可能乱码
                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 {
          // todo:关闭资源
        }
    }
}

注意：端口号一定要对应

文件上传
传输的是什么就用什么管道流，这里前半部分传输的是文件用文件的管道流，后半部分传输的是比特流，就用比特流管道
注意这里的输入输出是以服务器为参照，输入流表示输入服务器。
客户端

1、创建一个socket连接；
2、创建一个输出流；
3、准备输出数据，如果是一个文件，创建一个文件输入流，将文件读入内存并用buffer完成读写，并写入到输出流中；
4、通知服务器发送完成；
5、确认服务器接收完毕，客户端接收服务器发来的确认消息用ByteArrayOutputStream完成接收；
6、关闭资源

package socket.TCP;

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

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

        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream inputStream =null;
        ByteArrayOutputStream baos = null;
        try {
            //1、创建一个socket连接
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
            // 2 create an output stream
            os = socket.getOutputStream();

            // 3. file stream
            // 3.1 读入文件
            fis = new FileInputStream(new File("G://Code//Java//kuang//src//socket//TCP//lychee.jpg"));
            // 3.2 将这个文件写出
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer))!= -1){
                os.write(buffer,0,len);

            }
            // 通知服务器已经传输完成
            socket.shutdownOutput();  // 传输完成
            // 确定服务端接收完毕
            inputStream = socket.getInputStream();
            // getBytes返回的是byte[]类型
            baos = new ByteArrayOutputStream();

            byte[] buffer2 = new byte[1024];
            int len2;
            while((len2=inputStream.read(buffer2))!=-1){
                baos.write(buffer2,0,len2);
            }
            System.out.println(baos.toString());

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


    }
}

服务端

1、创建一个socket连接；
2、监听客户端的连接；
3、创建输入流对客户端发来的socket进行读取socket.getInputStream；
4、将输入流写出到内存；
5、通知客户端完成接收；
6、关闭资源。

package socket.TCP;

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

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

            // 1 create a socket
            ServerSocket serverSocket = new ServerSocket(9000);
            //2. listen to client
            Socket socket = serverSocket.accept();  // 阻塞式监听，会一直等待客户端连接
            // 3. get instream
            InputStream is = socket.getInputStream();  // 读取文件流

            // 4. 文件输出 将这个文件写出
            FileOutputStream fos = new FileOutputStream(new File("G://Code//Java//kuang//src//socket//TCP//receive.png"));

            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer))!= -1){  // 读取比特，用buffer存储，len表示实际buffer中存储了多少个byte
                fos.write(buffer,0,len);  // 从buffer中将0-len个写入到输出流中
            }

            // 通知客户端完成接收
            OutputStream os = socket.getOutputStream();
            os.write("recieved".getBytes());


            // 5. 关闭资源
            fos.close();
            is.close();
            socket.close();
            serverSocket.close();

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

Tomcat服务器

2.5 UDP

发短信：不用连接，但是需要知道对方地址
DatagramPacket、 DatagramSocket
基础实现UDPDemo01系列
发送端：

1、创建socket；
2、创建一个包用于发送；
3、发送这个包。

package socket.UDP;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

// 没有明确的客户端和服务端，这里只是做个区分
// 不需要连接服务端
public class UdpSendDemo01 {
    public static void main(String[] args) {

        try {
            // 1. 建立一个socket
            DatagramSocket socket = new DatagramSocket();

            // 2. 创建一个包
            // 2.1 需要发送的数据
            String msg = "你好啊，服务器！";
            //  2.2 服务器地址、端口号
            InetAddress localhost = InetAddress.getByName("localhost");
            int port = 9090;
            // 2.3 创建这个包
            DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

            // 3. 发送这个包
            socket.send(packet);

            // 4. 关闭流
            socket.close();

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

    }
}

接收端：

1、开放这个端口；
2、创建一个包用于接收；
3、接收一个发送端发来的包。

package socket.UDP;

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

// 没有明确的服务端概念，这里只是为方便区分

// 接收端：等待发送端的发送
public class UdpReceivedDemo01 {
    public static void main(String[] args) {

        try {
            // 1. 开放端口
            DatagramSocket socket = new DatagramSocket(9090);

            // 2. 接收
            // 2.1 创建接收的包容器
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
            // 2.2 接收
            socket.receive(packet);  // 阻塞接收

            System.out.println(packet.getAddress().getHostAddress());
            System.out.println(new String(packet.getData()));  // 显示
            // 3. 关闭
            socket.close();

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

实现单方面循环发送Chat01系列
发送端
关键在于从控制台读取数据

package socket.Chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.*;

public class UdpSenderDemo01 {
    public static void main(String[] args) {
        new Thread();


        try {
            // 1、 创建socket
            DatagramSocket socket = new DatagramSocket(8888);
            // 2、创建包
            // 准备数据信息

            byte[] buffer = new byte[1024];
            // 从控制台读取
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            while(true){
                String data = reader.readLine();
                DatagramPacket packet = new DatagramPacket(data.getBytes(),0,data.getBytes().length,new InetSocketAddress("localhost",8080));
                // 3、发送包
                socket.send(packet);
                if(data.contains("bye")){
                    System.out.println("see you~");
                    break;
                }

            }
            // 4 close
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

接收端

package socket.Chat;

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

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

        try {
            // 1、开启端口
            DatagramSocket socket = new DatagramSocket(8080);
            // 2、接收包

            while(true){
                byte[] msg = new byte[1024];  // 准备接收的包裹
                DatagramPacket packet = new DatagramPacket(msg, 0, msg.length);


                socket.receive(packet);  // 阻塞式接收包裹
                // 3、显示并判断
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(receiveData);
                if (receiveData.contains("bye")) {
                    System.out.println("see you~");


                    break;

                }

            }
            System.out.println("end");
            socket.close();





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

    }
}

两方都能循环发送循环接收Chat02系列
1、首先准备发送数据的线程；
2、再准备接收的数据的线程；
3、给双方开两个线程。
循环发送的线程：

package socket.Chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSender implements Runnable{

    DatagramSocket socket = null;
    BufferedReader reader = null;
    DatagramPacket packet = null;
    private int fromPort;
    private String toIP;
    private int toPort;
    //byte[] buffer = null;

    public TalkSender(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            //this.buffer = new byte[1024];
            this.socket = new DatagramSocket(this.fromPort);
            this.reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        // 发送消息
        try {
            // 从控制台读取

            while(true){
                String data = this.reader.readLine();
                this.packet = new DatagramPacket(data.getBytes(),0,data.getBytes().length,new InetSocketAddress(toIP,toPort));
                // 3、发送包
                this.socket.send(packet);
                if(data.contains("bye")){
                    System.out.println("see you~");
                    break;
                }

            }
            // 4 close
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


}

循环接收的线程：

package socket.Chat;

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

public class TalkReceiver implements Runnable{
    DatagramSocket socket = null;
    DatagramPacket packet = null;
    private int port;
    private String msgFrom;

    public TalkReceiver(int port,String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(this.port);  // 打开这个端口

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

    @Override
    public void run() {
        while(true){
            try {
                byte[] buffer = new byte[1024];
                packet = new DatagramPacket(buffer,0,buffer.length);
                this.socket.receive(this.packet);
                String data = new String(packet.getData(),0,packet.getData().length);
                System.out.println(msgFrom + data);
                if(data.contains("bye"))
                    break;
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();


    }


}

两个聊天双方,注意端口对齐：

package socket.Chat;

public class TalkStudent {
    public static void main(String[] args) {
        // 开启两个线程
        new Thread(new TalkSender(6666,"localhost",9999)).start();
        new Thread(new TalkReceiver(8888,"teacher：")).start();
    }
}

package socket.Chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSender(7777,"localhost",8888)).start();
        new Thread(new TalkReceiver(9999,"student：")).start();

    }
}

2.6 URL

https://www.zhihu.com/hot
统一资源定位符：定位资源的，定位互联网上的某个资源。
1、协议：//IP地址:端口/项目名/资源
2、下载一个网络资源

1、创建一个URL，地址为资源地址；
2、用Http连接这个资源；
3、获取输入流；
kage socket.Chat;

public class TalkStudent {
public static void main(String[] args) {
// 开启两个线程
new Thread(new TalkSender(6666,“localhost”,9999)).start();
new Thread(new TalkReceiver(8888,“teacher：”)).start();
}
}


```java
package socket.Chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSender(7777,"localhost",8888)).start();
        new Thread(new TalkReceiver(9999,"student：")).start();

    }
}

2.6 URL

https://www.zhihu.com/hot
统一资源定位符：定位资源的，定位互联网上的某个资源。
1、协议：//IP地址:端口/项目名/资源
2、下载一个网络资源

1、创建一个URL，地址为资源地址；
2、用Http连接这个资源；
3、获取输入流；
4、从输入流中读取字节，并写入文件输出流。

ThetaQing

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
socket编程

网络编程1 基本知识1.1 概述计算机网络：利用通信线路和通信设备，将地理位置不同的、功能独立的多台计算机互连起来，以功能完善的网络软件来实现资源共享和信息传递，就构成了计算机网络系统。网络编程的目的：传播交流信息，数据交换，通信想要达到这个目的需要什么：1、如何准确地定位网络上地一台主机 192.168.16.124：端口，定位到该计算机上的某个资源；2、找到了这个主机，如何传输数据呢？传输介质1.2 网络通信的要素如何实现网络的通信：通信双方的地址：ip+端口号规则1.3
复制链接

扫一扫