网络编程

最新推荐文章于 2023-06-24 21:33:09 发布

Stay_up_Victory

最新推荐文章于 2023-06-24 21:33:09 发布

阅读量252

点赞数

分类专栏： NetWork

本文链接：https://blog.csdn.net/Stay_up/article/details/72812227

版权

NetWork 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一：网络编程三要素和UDP协议
1.1
1.网络通信
2.tcp/ip
3.udp/ip

1.2
Socket通信
* 网络编程三要素：
ip:
一个计算机的标示（找到这个计算机）
端口：
每个应用程序都会对应一个端口，用来进行通信，有效端口：0~65535，其中0~1024为系统使用或保留端口
协议：
总共有2种协议（TCP,UDP）

* 举例说明：如果你要找一个你的同学说话，
* 1.先找到你的同学（ip值）
* 2.对着同学的耳朵说话（端口），
* 3.遵守什么协议

1.3
三要素详解：
特殊的IP地址:127.0.0.1 本地回环地址用来做一些本地测试
ping IP地址 ; 用来检测本机是否可以和指定的IP地址的计算机可以进行正常通讯
ipconfig 用来查看IP地址
xxx.xxx.xxx.255 广播地址
端口号:物理端口物理设备对应的端口 , 网卡口
逻辑端口用来标示我们的计算机上的进程 , 端口号的有效范围应该是 0-65535 ,其中0-1024被系统占用或者保留

协议:

UDP（协议）
把数据打成一个数据包 , 不需要建立连接
数据包的大小有限制不能超过64k
因为无连接,所以属于不可靠协议(可能丢失数据)
因为无连接 ,所以效率高
TCP
需要建立连接,形成连接通道
数据可以使用连接通道直接进行传输,无大小限制
因为有链接,所以属于可靠协议
因为有链接,所以效率低

1.4 （InetAddress）
InetAddress:IP地址的描述类
A:InetAddress类的概述
为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress 供我们使用
此类表示互联网协议 (IP) 地址。
B:InetAddress类的常见功能
public static InetAddress getByName(String host)（ host: 可以是主机名,也可以是IP地址的字符串表现形式）
public String getHostAddress()返回 IP 地址字符串（以文本表现形式）。
public String getHostName()获取此 IP 地址的主机名。
注意：InetAddress中没有构造方法所以我们在创建InetAddress的对象的时候，可以利用一些成员方法的返回值类型是InetAddress,

public class InetAddressDemo {
    public static void main(String[] args) throws Exception {
        //通过主机ip获取InetAddress对象
        InetAddress address = InetAddress.getByName("192.168.20.25");

        //public String getHostAddress()返回 IP 地址字符串（以文本表现形式）。
        System.out.println(address.getHostAddress());

        //public String getHostName()获取此 IP 地址的主机名。 
        System.out.println(address.getHostName());

    }

}

1.5（也叫socket编程，套接字编程，网络编程，
叫法不同，但本质上是一致的）
Socket套接字：（指的是ip和端口的组合）
网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

Socket原理机制：（通信的两端分别是服务端和客户端）
通信的两端都有Socket。
网络通信其实就是Socket间的通信。
数据在两个Socket间通过IO传输。

1.6
* UDP协议：（写一个标准demo）
特点：1.把数据打包
2.不需要建立连接，也称为面向无连接协议
3.数据需打包，数据大小有限制64k
4.无需建立连接，所以不可靠
5.效率高但是不安全

          UDP通信步骤：
                发送端步骤：
                /*（客户端）
                 * UDP发送数据的步骤:
                 * A:创建UDP发送数据端Socket对象
                 * B:创建数据包,并给出数据,把数据打包
                 * C:通过Socket对象发送数据包 
                 * D:释放资源
                 */

                 接收端步骤：
                /*（服务端）
                 * UDP协议接收数据步骤：
                 * A:创建UDP接收数据端Socket对象
                 * B:创建一个接收数据的数据包
                 * C:接收数据,数据在数据包中
                 * D:解析数据包，并把数据显示在控制台
                 * E:释放资源
                 */

1.8 键盘录入数据实现数据的动态发送

package com.edu_03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UdpClient {
    public static void main(String[] args) throws Exception {
        //1.创建发送端的socket对象
        DatagramSocket ds = new DatagramSocket();

        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 9999;

        //2.创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        String line;
        while ((line=sc.nextLine())!=null) {
            //键盘录入的数据line
            byte[] buf = line.getBytes();
            int length = buf.length;
            DatagramPacket dp = new DatagramPacket(buf, length, address, port);
            //发送数据包
            ds.send(dp);
        }

        //释放资源
        ds.close();

    }

}

package com.edu_03;

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

public class UdpServer {
    public static void main(String[] args) throws Exception {
        //创建接收端的socket对象
        DatagramSocket ds = new DatagramSocket(9999);

        //接受来自客户端的数据
        while (true) {
            //创建数据包
            byte[] buf = new byte[1024];
            int length = buf.length;
            DatagramPacket dp = new DatagramPacket(buf, length);

            //接受来自客户端的数据
            ds.receive(dp);

            //解析数据包中的数据
            byte[] data = dp.getData();
            int len = dp.getLength();
            System.out.println(new String(data, 0, len));

        }

    }

}

1.9 dos命令行演示聊天室（多个窗口实现群聊）
我们在dos 窗口运行的时候，可以开启一个服务端，利用多个客户端去传送数据

1.10 多线程实现聊天室（相当于是将发送数据端和接收数据端合并）

要实现对个窗口的群聊，我们需要利用线程的方法，让程序的效率更高一些
package com.edu_04;


import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UdpCilent implements Runnable{

    DatagramSocket ds ;

    public UdpCilent(DatagramSocket ds){
        this.ds = ds;
    }

    @Override
    public void run() {
        try {
            InetAddress address = InetAddress.getByName("192.168.20.255");
            int port = 9999;
            //定义端口的时候，只能利用0~65535之间数值，并且0~1024被系统占据

            //2.创建键盘录入对象
            Scanner sc = new Scanner(System.in);
            String line;
            while ((line=sc.nextLine())!=null) {
                //键盘录入的数据line
                byte[] buf = line.getBytes();
                int length = buf.length;
                DatagramPacket dp = new DatagramPacket(buf, length, address, port);
                //发送数据包
                ds.send(dp);
            }

            //释放资源
            ds.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

二：TCP协议要点
2.1
* TCP协议：（写一个demo）
特点：1.需要建立通道
2.传送大量数据无限制
3.面向连接
4.可靠
5.速度慢
TCp协议书写步骤：
发送端：
/*
* TCP协议发送数据步骤：
* A:创建TCP协议发送端Socket对象
* 指定服务器IP及端口
Socket sk = new Socket(“192.168.3.120” , 9527) ;
* B:获取输出流,并写数据
OutputStream outputStream = sk.getOutputStream() ;
outputStream.write(“hello,TCP我来了”.getBytes()) ;
* C:释放资源
sk.close() ;
*
* java.net.ConnectException: Connection refused: connect
* TCP协议是不能直接运行客户端的，必须先运行服务器。因为他是一种可靠的协议。
*/

             接收端：
             /*
                 * TCP协议接收数据步骤：
                 * A:创建TCP协议接收端Socket对象
                   ServerSocket ss = new ServerSocket(9527) ;
                 * B:监听客户端连接
                   Socket sk = ss.accept() ;
                 * C:获取输入流,并读取数据,显示在控制台
                 // 读取数据
                byte[] bytes = new byte[1024] ;
                int len = inputStream.read(bytes) ;

                // public InetAddress getInetAddress()获取IP地址
                InetAddress inetAddress = sk.getInetAddress() ;
                String ip = inetAddress.getHostAddress() ;

                // 输出
                System.out.println(ip + "发来数据是: " + new String(bytes , 0 , len));
                 * D:释放资源
                 sk.close() ;
                 */

2.2
用TCP协议写一个数据的发送和接收，接收端接收到数据之后给发送端一个反馈

客户端：
package com.edu_06;


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

public class TcpClient {
    public static void main(String[] args) throws Exception {
        //创建tcp发送端的sockt对象
        Socket sk = new Socket("127.0.0.1", 10000);

        //从通道中获取输出流
        OutputStream os = sk.getOutputStream();

        //网通道中写数据
        os.write("今晚约吗".getBytes());

        //接受来自服务器端的反馈
        InputStream is = sk.getInputStream();
        //解析is
        byte[] buf = new byte[1024];
        int len = is.read(buf);
        System.out.println(new String(buf, 0, len));

        //释放资源
        sk.close();

    }

}
服务端：
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    public static void main(String[] args) throws Exception {
        //创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听来自客户端的连接
        Socket sk = ss.accept();

        //从通道中获取输入流读取数据
        InputStream is = sk.getInputStream();

        //解析is
        byte[] buf = new byte[1024];
        int len = is.read(buf);
        System.out.println(new String(buf, 0, len));


        //给客户端一个反馈
        OutputStream os = sk.getOutputStream();
        os.write("不约".getBytes());


        //释放资源
        sk.close();


    }

}

注意：在运行程序的时候，不能先运行客户端，会抛出java.net.ConnectException: Connection refused: connect 异常
，因为服务端还没有建立一个链接，客户端就将数据传输过来了，因此会抛出异常，由此也证明了tcp协议是面向连接过程的一个协议
2.3
以2.3的案例代码为基础，tcp协议数据的发送和接收
tcp协议在传输过程的时候，是需要一连接的，首先在客户端和服务端分别创建socket对象，而在服务端的socket对象必须调用accept方法，因为他要监听来自客户端的链接，一旦连接成功之后，客户端和服务端会形成一个传递信息的通道，客户端利用IO流将数据写入同道中，服务端将数据读取，这就完成了数据在客户端和服务端的传递
2.4
需求: 客户端键盘录入数据,服务器端接收数据在控制台输出

package com.edu_07;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 *  2.4
    需求: 客户端键盘录入数据,服务器端接收数据在控制台输出
 *   
 */
public class TcpClient {
    public static void main(String[] args) throws Exception {
        //创建tcp发送端socket对象
        Socket sk = new Socket("192.168.191.1", 20000);

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        String line;
        while ((line=sc.nextLine())!=null) {
            //将line这个数据写如通道
            OutputStream os = sk.getOutputStream();
            os.write(line.getBytes());

        }

        sk.close();

    }

}

2.5
需求：客户端键盘录入数据，服务端将数据写入文件


package com.edu_08;
客户端
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class TcpClient {
    public static void main(String[] args) throws Exception {
        /**
         * 2.5
            需求：客户端键盘录入数据，服务端将数据写入文件
            客户端
            一次写一行

            服务端：
            一次读取一行，将读取到的内容写入文件
         */
        //创建tcp客户端socket对象
        Socket sk = new Socket("127.0.0.1", 10010);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        String line;
        while ((line=sc.nextLine())!=null) {
            //往通道中写数据，一次写一行
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        sk.close();
    }

}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
服务端：
public class TcpServer {
    public static void main(String[] args) throws Exception {
        //创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(10010);

        //监听客户端连接
        Socket sk = ss.accept();

        //从sk的通道中读取数据，一次读取一行
        BufferedReader br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        //一次读取一行数据
        String line;
        while ((line=br.readLine())!=null) {
            //line就是已经读取到的数据，我们现在需要将line这个数据写入文件
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        sk.close();
        bw.close();
        br.close();

    }

}

2.6
需求：客户端读取文本文件中的内容发送给服务端，服务端将内容控制台输出

package com.edu_09;

import java.io.BufferedReader;
public class TcpClient {
    public static void main(String[] args) throws Exception {
        //创建socket对象
        Socket sk = new Socket("192.168.20.254", 2000);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));

        //读取文本一次读取一行
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        String line;
        while ((line=br.readLine())!=null) {
            //line就是我读取到的数据，我需要将这个数据写入通道，一次写一行
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        br.close();
        bw.close();
        sk.close();

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    public static void main(String[] args) throws Exception {
        //创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(2000);

        //蒋婷来自于客户端的连接
        Socket sk = ss.accept();

        //创建BufferedReader一次读取一行数据
        BufferedReader br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }

        //释放资源
        br.close();
        sk.close();

    }

}

注意：
我们在UDP协议中，再创建socket对象的时候调用的是DatagramSocket()这个方法，在传输数据的时候，需要创建数据包，调用的是DatagramPacket（）方法，在接受数据的时候我们还需要创建一个空包来读取数据。
而在TCP协议中我们创建客户端对象的时候，我们可以调用Socket方法，直接将ip地址和端口传进去，而在创建服务端的对象的时候，我们要调用ServerSocket（）方法，然后在调用accept方法，监听来自客户端的链接。在运行的时候，我们先运行服务端，程序运行在ss.accept()阻塞，然后运行客户端，服务端与客户端建立链接，程序才能继续往下运行

2.7
* 需求: 上传文本文件
*
* 客户端:
* a: 读取文本文件中的数据
* b: 发送到服务器端
*
* 服务器:
* a: 读取流通道中的数据
* b: 把数据写入到文本文件中

2.8
运用多线程改进2.7

package com.edu_10;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 2.6  
    需求：客户端读取文本文件中的内容发送给服务端，服务端将内容控制台输出
 *  客户端：
 *  1.读取文本文件，一次读取一行
 *  2.将读取到的内容写入通道，一次写一行
 *  3.释放资源
 *  服务器端：   
 *  1.从通道中读取数据，一次读取一行
 *  2.输出
 */
public class TcpClient {
    public static void main(String[] args) throws Exception {
        //创建socket对象
        Socket sk = new Socket("192.168.20.254", 2000);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));

        //读取文本一次读取一行
        BufferedReader br = new BufferedReader(new FileReader("InetAddressDemo.java"));
        String line;
        while ((line=br.readLine())!=null) {
            //line就是我读取到的数据，我需要将这个数据写入通道，一次写一行
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        br.close();
        bw.close();
        sk.close();

    }

}
package com.edu_10;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerThread implements Runnable{
    Socket sk;
    public ServerThread(Socket sk){
        this.sk = sk;
    }

    @Override
    public void run() {
        try {
            //创建BufferedReader一次读取一行数据
            BufferedReader br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
            BufferedWriter bw = new BufferedWriter(new FileWriter(UUIDUtils.getFileName()));
            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
                //System.out.println(line);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer {
    public static void main(String[] args) throws Exception {
        //创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(2000);

        while (true) {
            //蒋婷来自于客户端的连接
            Socket sk = ss.accept();
            //启动一个子线程，去执行复制文件的动作
            new Thread(new ServerThread(sk)).start();
        }

    }

}
//创建UUIDUtils类，用于创键随机产生的文件名称
import java.util.UUID;
import org.junit.Test;

public class UUIDUtils {
    @Test
    public static String getFileName(){
        String fileName = UUID.randomUUID().toString();
        fileName = fileName.replaceAll("-", "")+".txt";
        return fileName;
    }

}

注意：在上传文件的时候，我们可以利用 UUID这个类，获取类型 4（伪随机生成的）UUID 的静态工厂。使用加密的强伪随机数生成器生成该 UUID。
2.9
提问：我们以后倒是使用udp协议还是tcp协议呢？
在咱们以后使用的软件当中基本都是udp和tcp混用的

Stay_up_Victory

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网络编程

一：网络编程三要素和UDP协议 1.1 1.网络通信 2.tcp/ip 3.udp/ip1.2 Socket通信 * 网络编程三要素： ip: 一个计算机的标示（找到这个计算机）端口：每个应用程序都会对应一个端口，用来进行通信，有效端口：0~65535，其中0~1024为系统使用或保留端口
复制链接

扫一扫

专栏目录