Java-网络编程

网络编程

一、概述

• 计算机网络：
  • 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
• 网路编程的目的：
  • 传播交流信息。
  • 数据交换。
  • 通信。
• 想要达到这个效果需要什么：
  • javaWeb：网页编程 B/S 架构
  • 网络编程：TCP/IP C/S 架构

二、网路通信的要素

• 通信双方地址
  • ip
  • 端口号
• 规则：网络通信的协议

  • TCP/IP 参考模型：

    OSI 七层网络模型	TCP/IP 四层概念模型	对应网络协议
    应用层（Application）	应用层	HTTP、TFTP、FTP、NFS、WAIS、SMTP
    表示层（Presentation）		Telnet,Rlogin,SNMP,Gopher
    会话层（Session）		SMTP,DNS
    传输层（Transport）	传输层	TCP,UDP
    网络层（Network）	网络层	IP,ICMP,ARP,RARP,AKP,UUCP
    数据链路层（Data Link）	数据链路层	FDDI,Ethernet,Arpanet,PDN,SLIP,PPP
    物理层（Physical）		IEEE 802.1A,IEEE 802.2 到 IEEE 802.11

三、IP 地址

• ip 地址

  • Java 表示 ip 地址的类：InetAddress
  • 唯一定位一台网络上计算机
  • 127.0.0.2：本机 localhost

• ip 地址分类

  • ipv4 / ipv6
    • ipv4：127.0.0.1，4 个字节组成。0~255位，42 亿个
    • ipv6：fe80::70cf:506b:7dc7:dd9e%41，128 位。8 个无符号整数
  • 公网(互联网)-私网(局域网)
    • 192.168.xx.xx：专门给组织内部使用的
    • ABCD 类地址

• 域名：解决 IP 地址记忆问题!

  • IP：www.jd.com

• InetAddress 类的使用

  • 此类表示Internet协议（IP）地址。

  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 inetAddress2 = InetAddress.getByName("localhost");
              System.out.println(inetAddress2);
              InetAddress inetAddress3 = InetAddress.getLocalHost();
              System.out.println(inetAddress3);
  
              // 查询网站 ip 地址
              InetAddress inetAddress = InetAddress.getByName("www.beidu.com");
              System.out.println(inetAddress);
  
              System.out.println("============");
  
              // 常用方法
              System.out.println(inetAddress.getAddress());
              System.out.println(inetAddress.getCanonicalHostName()); // 获得规范的名字
              System.out.println(inetAddress.getHostAddress()); // 获得 ip
              System.out.println(inetAddress.getHostName()); // 获得 域名
  
          } catch (UnknownHostException e) {
              e.printStackTrace();
          }
      }
  }
  

四、端口

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

  • 不同的进程有不同的端口号！用来区分软件！

  • 被规定 0~65535 个进程

  • TCP,UDP：68835*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 "135" # 查看指定的端口
    tasklist | findstr "14080" # 查看指定端口的进程
    

  • InetSocketAddress 类

    • 该类实现IP套接字地址（IP地址+端口号）它也可以是一对（主机名+端口号），在这种情况下将尝试解析主机名。

    import java.net.InetSocketAddress;
    
    public class TestInetSocketAddress {
        public static void main(String[] args) {
            InetSocketAddress socketAddress1 = new InetSocketAddress("127.0.0.1", 8080);
            System.out.println(socketAddress1);
            InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
            System.out.println(socketAddress2);
    
            // 常用方法
            System.out.println(socketAddress1.getAddress());
            System.out.println(socketAddress1.getHostName()); // 返回地址
            System.out.println(socketAddress1.getPort()); // 返回端口
        }
    }
    

五、通信协议

• 协议：约定，就好比我们现在说的是普通话。
• 网络通信协议：速率，传输码率，代码结构，传输控制...
• TCP/IP 协议簇：实际上是一组协议
  • TCP：用户传输协议
  • IP：网络互联协议
• 两个重要的协议：
  • TCP：用户传输协议
  • UDP：用户数据报协议
• TCP UDP 对比
  • TCP：打电话
    • 三次握手``四次挥手
    • 客户端、服务端
    • 传输完成，释放连接，效率低
  • UDP：发短信
    • 不连接，不稳定
    • 客户端、服务端：没有明确的界限
    • 不管有没有准备好，都可以发送给你

六、TCP 实现聊天

客户端

1. 连接服务器 Socket
2. 发送消息

package com.kuang.lesson02;

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

// 客户端
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 连接
            socket = new Socket(serverIP,port);
            // 4. 发送消息 IO 流
            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.kuang.lesson02;

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();
                // 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());

            }
        } 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();
                }
            }
        }
    }
}

七、TCP 文件上传实现

客户端

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("header.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[1024];
        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();
    }
}

服务器

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
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());

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

八、初识 Tomcat

• 服务端
  • 自定义 S
  • Tomcat 服务器 S
• 客户端
  • 自定义 C
  • 浏览器 B

Tomcat 启动时乱码：到 conf/logging.properties 文件中把 java.util.logging.ConsoleHandler.encoding = UTF-8 修改为 java.util.logging.ConsoleHandler.encoding = GBK

九、UDP 消息发送

发送端

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


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

        // 2. 建个包
        String msg = "你好啊，服务器！";

        // 发送给谁
        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();
    }
}

接收端

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

// 等待客户端的链接！
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();
    }
}

十、UDP 循环发送接收

发送方

package com.kuang.chat;

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

public class UdpSenderDemo01 {
    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();
    }
}

接收方

package com.kuang.chat;

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

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();
    }
}

十一、UDP 多线程在线咨询

发送线程

package com.kuang.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 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));
        } catch (SocketException 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;
                }
            } catch (Exception e){
                e.printStackTrace();
            }
        }

        socket.close();
    }
}

接收线程

package com.kuang.chat;

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

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 (SocketException 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); // 阻塞式接收包裹

                // 断开连接 bye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom + ": " + receiveData);

                if (receiveData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

学生端

package com.kuang.chat;

// 学生
public class TalkStudent {
    public static void main(String[] args) {
        // 开启两个线程
            // 学生自己的端口：7777
            // 学生接收端口：8888
            // 老师接收端口：9999
        new Thread(new TalkSend(7777,"localhost",9999)).start(); // 发送线程
        new Thread(new TalkReceive(8888,"老师")).start(); // 接收线程
    }
}

老师端

package com.kuang.chat;

// 老师
public class TalkTeacher {
    public static void main(String[] args) {
        // 开启两个线程
        // 老师自己的端口：5555
        // 学生接收端口：8888
        // 老师接收端口：9999
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

十二、URL

统一资源定位符：定位资源的，定位互联网上的某一个资源

格式：
协议://IP地址:端口号/项目名/对应资源

12.1、下载网络资源

public static void main(String[] args) throws IOException {
    // 1. 下载地址
    URL url = new URL("http://localhost:8080/qinjiang/SecurityFile.txt");

    // 2. 连接到这个资源 HTTP
    HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();

    InputStream inputStream = urlConnection.getInputStream();
    FileOutputStream fos = new FileOutputStream("王宇.txt");

    byte[] buffer = new byte[1024];
    int len;
    while ((len=inputStream.read(buffer))!=-1){
        fos.write(buffer,0,len); // 写出这个数据
    }

    fos.close();
    inputStream.close();
    urlConnection.disconnect(); // 断开连接
}