网络编程学习笔记（狂神酱的）

最新推荐文章于 2025-05-23 19:45:00 发布

以后技术棒

最新推荐文章于 2025-05-23 19:45:00 发布

阅读量363

点赞数 1

分类专栏： Java 文章标签：网络 socket java 网络通信

本文链接：https://blog.youkuaiyun.com/qq_47239483/article/details/117253421

版权

Java 专栏收录该内容

9 篇文章

订阅专栏

网络编程

1.1概念

打电话 – 连接 – 接电话通了称为： TCP
发短信 – 发了就等他运输就完了 – 接收称为： UDP

什么是计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

javaweb：网页编程 B/S
网络编程：TCP/IP C/S

1.2网络编程的要素

通信双方的地址：

ip
端口
192.168.1.1：5900
通过ip和端口定位一个位置

规则：网络编程的协议

TCP/IP参考模型：

主要看传输层。

1、网络编程的两个问题：

定位到网络上的一台或多台主机
找到了主机之后如何进行通信

2、网络编程的要素

IP和端口号
网络通信协议

3、万物皆对象

1.3IP

ip地址：InetAddress

唯一定位一台网络上的计算机
127.0.0.1：本机的localhost
IP地址的分类
- ipv4 / ipv6
  - ipv4： 127.0.0.1 ，由四个字节组成，单个长度为0~255，42亿个
  - ipv6：128位。八个无符号整数
```
2001:adad:aaa2:0022:2222:1231:1231:asd2
```
公网（互联网）-私网（局域网）
- 192.168.x.x 给组织内部区域用的
- ABCD类的地址
域名：记忆IP的问题！
- IP：www.baidu.com

package com.bang.lensson01;

import java.net.InetAddress;
import java.net.UnknownHostException;

//测试IP
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);

            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);

            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            //查询网站IP地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用方法
            System.out.println(inetAddress2.getAddress());
            System.out.println(inetAddress2.getCanonicalHostName());//获得规范的名字
            System.out.println(inetAddress2.getHostAddress());//获得主机的名字 IP
            System.out.println(inetAddress2.getHostName());//域名，或者自己电脑的名字


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

查询百度所得到的

[B@135fbaa4
14.215.177.39
14.215.177.39
www.baidu.com

1.4端口

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

不同的进程有不同的端口号，用来区分软件
被规定有0~65535个
有TCP和UDP两个协议可以用，所以有65535*2个的总和可以用。tcp用80时，udp也可以用80。但是单个协议下，端口不可以冲突。
端口分类
- 公有端口0~1023
  - HTTP：80
  - HTTPS：443
  - FTP:21
  - Telent:23
- 程序注册端口：1024~49151，分配给用户或者程序的
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
  - 动态、私有：49152~65535

在cmd里面关于端口的功能

     netstat  -ano #查看所有端口
     netstat  -ano|findstr "5900 " #查询端口
     tasklist|findstr "8696"  #查看指定端口的进程
     ctrl + shift +esc  # 打开任务管理器

关于端口的代码

package com.bang.lensson01;

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress=new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2=new InetSocketAddress("127.0.0.1",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());//地址
        System.out.println(socketAddress.getPort());//端口
    }
}

结果为

/127.0.0.1:8080
/127.0.0.1
transact.netsarang.com
8080

1.5通信协议

协议：约定
网络通信协议：速率，传输码率，代码结构，传输控制…
大事化小：分层
TCP/IP协议簇：实际上是一组协议
重要：

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

出名的协议：

TCP
IP：网络互连协议

TCP和UDP的对比
TCP：打电话

连接，稳定
三次握手，四次挥手

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

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

客户端、服务期
传输完成，释放连接，效率低

UDP：发短信

不连接，不稳定
客户端、服务端：没有明确的界限
不管有没有准备好都可以发送到
DDOS：洪水攻击

1.6TCP

客户端
1、连接服务器的socket（插座）
2、发送信息

//客户端
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("你好，网络编程".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //释放资源
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

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

    }
}

服务器
1、建立服务器的端口ServerSocket
2、等待用户的连接accpet
3、接收用户的消息

//服务端
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();
                //3.读取客户端的消息
                is = socket.getInputStream();
                //管道流
                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());
            }


  /*

              byte[] buffer = new byte[1024];//new个缓冲区
              int len;//判断所读区域的大小
              while ((len=is.read(buffer))!=-1){ //假设不等于负一就说明里面还有值
                //写出去
                    String msg = new String(buffer, 0, len);
                    System.out.println(msg);
            }
             */

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源，先开后关

            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 (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

以上为传输数据

传输文件
客户端：

package com.bang.lensson02;

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


public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1、创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2、创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3、得先读文件，再把文件输出去
        FileInputStream fis = new FileInputStream(new File("花.png"));
        //4、写出文件，把文件传输出去
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput();//已经传输完了


        //确定服务器段接受到了文件才能断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[]类型
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

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

        System.out.println(baos.toString());

        //5、关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

    }
}

服务器端：

package com.bang.lensson02;

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

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1、创建服务端口
        ServerSocket serverSocket = new ServerSocket(9000);
        //2、监听客户端的连接，没连接过来是不会停的
        Socket socket = serverSocket.accept();//阻塞式连接，会一直等待客户端连接
        //3、获取输入流
        InputStream is = socket.getInputStream();//得到当前文件

        //4、文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.png"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //通知客户端接受完毕了
        OutputStream os = socket.getOutputStream();
        os.write("接收完毕".getBytes());//返回成为bytes数组类型

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

1.7UDP

发送消息，可以不用实时连接

发送端

package com.bang.lesson03;

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

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1、建立一个socket连接
        DatagramSocket socket = new DatagramSocket();

        //2、创建一个包
        String msg="东风导弹101";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        //数据，数据的长度起，数据的长度终，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

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

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


    }
}

接收端：

package com.bang.lesson03;

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

//还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接受数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接受包，可以不需要地址的说明

        socket.receive(packet);//阻塞接收

        //解释包裹里面的东西
        System.out.println(packet.getAddress().getHostAddress());//得到发出来的地址的
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        //关闭连接
        socket.close();


    }
}

循环发送消息

public class UdpSenderDeml01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据；控制台读取system.in

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true){
            String data = reader.readLine();//读取这一行
            byte[] datas = data.getBytes();//转换成字节

            DatagramPacket packet=new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));


            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }


        socket.close();

    }
}

循环接收消息


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

        DatagramSocket socket = new DatagramSocket(6666);


        while(true){   //死循环的接收包裹

            //准备接收的包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet);//阻塞式接收包裹

            //断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);//把数据读出来
           //读出数据是什么
            System.out.println(receiveData);

            if (receiveData.equals("bye")){
                break;
            }


        }

        socket.close();


    }
}

实现聊天:

发送类

public class TalkSend implements Runnable{
    DatagramSocket socket = null;//建立连接应该在很上面的位置
    BufferedReader reader = null;

    //写对方的端口号
    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) { //告诉自己是谁，需要往哪儿发，建立连接了
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try{
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));//之前提升了作用域之后没有去删除，是导致了bug的
            

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


    }


    @Override
    public void run(){

        //准备数据；控制台读取system.in
        while (true){ //只管一直发送消息
            try{
                String data = reader.readLine();//读取这一行
                byte[] datas = data.getBytes();//转换成字节

                DatagramPacket packet=new DatagramPacket(datas,0, datas.length,new InetSocketAddress(this.toIP,this.toPort));

                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收类：

public class TalkReceive implements Runnable{
    DatagramSocket socket =null;

    private int port;//自己的端口
    private String msgFrom;//信息从哪儿来

    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom=msgFrom;

        try {
            socket = new DatagramSocket(port);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){   //死循环的接收包裹

            try {
                //准备接收的包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container,0,container.length);
                socket.receive(packet);//阻塞式接收包裹

                //断开连接
                byte[] data = packet.getData();//获得数据
                String receiveData = new String(data, 0, data.length);//把数据读出来，获得长度，获得一些消息
                //读出数据是什么
                System.out.println(msgFrom+"："+receiveData);//接收,改成了动态的

                if (receiveData.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }


        }

        socket.close();
    }
}

参与通信的两方：

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}



public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}