网络编程实战

网络编程

1.1 概述

网络编程的目的:

实现 无线电台---传播信息交流，数据交换，通信。

javaweb：网页编程

网络编程：TCP/IP

1.2 网络通信的要素

伦理问题 导致不能大规模生产使用

如何实现网络的通信？

通信双方的地址

• ip

• 端口号

规则：网络通信的协议

小结：

1. 网络编程中的两个主要问题 - 如何准确地定位网络上的一台或者多台主机 - 找到主机之后如何进行通信

2.网络编程中的要素

• ip和端口号

• 网络通信协议

1.3 IP

ip地址：InetAddress

• 唯一定位一台网络上的计算机

• 127.0.0.1 本机：localhost

• ip 地址的分分类

  • ipV4/ipv6

    • ipv4 : 127.0.0.1 , 4 个字节组成，，0~255 42亿

    • ipv6 : fe80::dd11:5ed6:79e5:fd73%21 128位，8个无符号整数

• 公网(互联网使用)-私网（局域网 192.168.XX.XX）

 

1.4 端口

表示一个进算计的一个程序的进程：

• 不同的进程有不同的端口号 端口号不能冲突，用来区分软件

• 被规定 0~65535

• TCP UDP ：65535 * 2 ，单个协议下，端口号不能冲突

• 端口分类：

  • 公有端口：0~1023

    • HTTP ： 80

    • HTTPS : 443

    • FTP : 21

    • Telnet ： 23

  • 程序注册端口：1024~49151，分配用户或者程序

    • Tomcat ： 8080

    • Mysql :3306

    • Oracle: 1521

  • 动态、私有： 49152~ 65535

    netstat -ano  #查看所有的端口
    netstat -ano|findstr "5990" # 查看指定的端口
    tasklist|findstr "5990" #查看指定端口的进程

     

1.5 通信协议

协议： 约定

网络通信协议：速率，传输的码率，代码结构，传输控制

问题：非常的复杂

分层：

TCP/IP协议簇（传输层）：实际上是一组协议

• TCP： 用户传输协议

• UDP：用户数据报协议

TCP UDP 对比： TCP : 打电话

• 连接：稳定

• 三次握手 四次挥手

  最少保证三次才能保证稳定连接
  A：你瞅啥
  B：瞅你咋地
  A：干一场
  ​
  A：我要断开了
  B：我知道你要断开了
  B: 你真的断开了吗
  A： 我真的要走了

• 客户端 服务端

• 传输完成，释放连接，效率低

UDP:

• 不连接，不稳定

• 客户端 服务端 没有明确的界限

• 不管有没有准备好都可以发给你

• DDOS攻击： 洪水攻击（饱和攻击）

1.6 TCP 实现聊天

客户端

1. 通过socket连接服务器

2. 发动消息

   package com.gentlesoft.oa.archives.controller;
   ​
   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");
               // 2. 要有一个端口号
               int port = 9999;
               // 3. 创建一个连接
                socket = new Socket(serverIp,port);
               // 4.发送消息
                os = socket.getOutputStream();
               os.write("你好，欢迎你".getBytes());
           } catch (Exception e) {
               e.printStackTrace();
           }finally {
               if(os!=null){
                   try {
                       os.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
               if(socket!=null){
                   try {
                       socket.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
   ​
           }
       }
   }
   ​

服务器

1. 建立服务的端口 ServerSocket

2. 等待用户的连接 accept

3. 接收用户的消息

package com.gentlesoft.oa.archives.controller;
​
import java.io.ByteArrayInputStream;
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 bao = null;
        // 1. 要有一个地址
        try {
             serverSocket = new ServerSocket(9999);
            // 2. 等待客户端连接过来
             socket = serverSocket.accept();
            // 3. 读取客户端的消息
             is =  socket.getInputStream();
           // 管道流
             bao =  new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){
                bao.write(buffer,0,len);
            }
            System.out.println(bao.toString());
​
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 关闭资源
            if(bao!=null){
                try {
                    bao.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();
                }
            }
​
        }
    }
}
​

1.7 文件上传

客户端

package com.gentlesoft.oa.archives.controller;
​
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
​
// 客户端
public class TcpClientDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
        // 2. 创建一个输出流
       OutputStream os =  socket.getOutputStream();
        //3. 文件流
        FileInputStream fis =  new FileInputStream(new File("绿色低碳重点项目表 1.xlsx"));
        // 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();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        // 5. 关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}
​

服务器端

package com.gentlesoft.oa.archives.controller;
​
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
​
// 服务器端 接收文件
public class TcpServerDemo01 {
    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("revice.xlsx"));
        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());
         // 关闭资源
         fos.close();
         is.close();
         socket.close();
         serverSocket.close();
    }
}
​

UDP

客户端

package com.gentlesoft.oa.archives.controller;
​
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
​
// UDP UDP 不需要连接服务器
public class TcpClientDemo01 {
​
        public static void main(String[] args) throws  Exception{
        // 1. 建立一个Socket
        DatagramSocket socket =  new DatagramSocket();
        // 2. 建立一个包
        String msg= "你好，服务器";
        // 3 发送给谁
        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.gentlesoft.oa.archives.controller;
​
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
​
// UDP 还是要等待客户端的连接
public class TcpServerDemo01 {
    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();
    }
}
​

 

UDP聊天的实现

发送端

package com.gentlesoft.oa.archives.controller;
​
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
​
public class UdpSendDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);
        // 准备数据 控制台读取 System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String data = reader.readLine();
        byte[] datas = data.getBytes();
        DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
​
        socket.send(packet);
        socket.close();
​
    }
}
​

接收端

package com.gentlesoft.oa.archives.controller;
​
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
​
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);
​
            // 断开连接 bye
            byte[] data  = packet.getData();
            String receiveData = new String(data,0,data.length);
            System.out.println(receiveData);
            if(receiveData.equals("bye")){
             break;
            }
        }
        socket.close();
    }
}
​
​

多线程在线聊天

学生端

    package com.gentlesoft.oa.archives.controller;
    // 开启线程
    public class Student {
        public static void main(String[] args) {
            // 开启两个线程
            new Thread(new UdpSendDemo01(7777,"localhost",9999)).start();
            new Thread(new UdpReceiveDemo01(8888,"老师")).start();
        }
    }
​

老师端

package com.gentlesoft.oa.archives.controller;
​
public class Teacher {
    public static void main(String[] args) {
        // 开启两个线程
        new Thread(new UdpSendDemo01(5555,"localhost",8888)).start();
        new Thread(new UdpReceiveDemo01(9999,"学生")).start();
    }
}
​

发送端

package com.gentlesoft.oa.archives.controller;
​
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
​
public class UdpSendDemo01 implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort ;
    private String toIP;
    private int toPort;
​
    public UdpSendDemo01(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try{
            socket = new DatagramSocket(fromPort);
            // 准备数据 控制台读取 System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
​
    @Override
    public void run() {
        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;
            }
            socket.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
​
    }
​
}
​

接收端

package com.gentlesoft.oa.archives.controller;
​
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
​
public class UdpReceiveDemo01 implements Runnable{
    DatagramSocket socket = null;
    private int port ;
    private String msgFrom;
​
    public UdpReceiveDemo01(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);
                try {
                    socket.receive(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
​
                // 断开连接 bye
                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();
    }
​
}
​

1.8 URL 统一资源定位符