第25章 网络编程

第25章 网络编程

1.网络基础知识

1.1.计算机进行通信的必备条件

1.IP地址。IP指明计算机在网络中的地址，每一天机器必须有一个唯一的标识：IP地址
2.协议。不同计算机之间使用同一种语言，方便说话
3.端口号。指明是计算机上哪一个进程在说话

1.用于区分不同应用程序
2.端口号范围：0-65535，其中0-1023为系统所保留
3.IP地址和端口号组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础

1.2.TCP/IP协议

是以TCP/IP为基础的不同层次上多个协议的集合。
TCP：传输控制协议
IP：互联网协议
常见的几种协议：
HTTP：超文件传输协议,端口号：80
FTP：文件传输协议，端口号：21
SMTP：简单邮件传送协议
Telnet：远程登录服务，端口号：23

2.java网络相关API的应用

2.1.java中的网络支持

针对网络通信的不同层次，java提供的网络功能有四大类
1.InetAddress：用于标识网络上的硬件资源
2.URL：统一资源定位符，通过URL可以直接读取或写入网络上的数据
3.Sockets:使用TCP协议实现网络通信的Socket相关的类
4.Datagram：使用UDP协议，将数据保存在数据报中，通过网络进行通信

2.2.InetAddress类

该类用于标识网络上的硬件资源，多用来表示互联网协议（IP）地址
该类没有构造方法，但是可以通过提供的静态方法获取本机的一个实例
常用方法如下：

public class testInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        //根据本地主机获取InetAdress实例
        InetAddress address = InetAddress.getLocalHost();
        //获取计算机名
        System.out.println("计算机名："+address.getHostName());//计算机名：rocco-All-Series
        //获取IP地址
        System.out.println("IP地址:"+address.getHostAddress());//IP地址:127.0.1.1
        //字节数组形式的IP：
        byte[] bytes = address.getAddress();
        System.out.println("字节数组形式的IP："+ Arrays.toString(bytes));//字节数组形式的IP：[127, 0, 1, 1]
        //直接输出InetAddress对象
        System.out.println(address);//rocco-All-Series/127.0.1.1

        //根据机器名获取InetAdress实例
        InetAddress address2 = InetAddress.getByName("rocco-All-Series");
        //获取计算机名
        System.out.println("计算机名："+address2.getHostName());//计算机名：rocco-All-Series
        //获取IP地址
        System.out.println("IP地址:"+address2.getHostAddress());//IP地址:127.0.1.1


        //根据IP地址获取InetAdress实例
        InetAddress address3 = InetAddress.getByName("127.0.0.1");
        //获取计算机名
        System.out.println("计算机名："+address2.getHostName());//计算机名：rocco-All-Series
        //获取IP地址
        System.out.println("IP地址:"+address2.getHostAddress());//IP地址:127.0.1.1

    }
}

2.3.URL

URL:统一资源定位符，表示Internet上某一资源的地址
URL:由两部分组成：协议名称和资源名称，中间用冒号分开
在java.net包中，提供了URL类来表示URL.
URL常用方法：

import java.net.MalformedURLException;
import java.net.URL;

/**
 * URl常用方法
 */
public class TestURL {
    public static void main(String[] args) {
        try {
            //创建一个URL实例
            URL imooc = new URL("http://www.imooc.com");
            //根据已经创建的URL实例，再创建一个URL实例出来
            URL url = new URL(imooc, "/index.html?username=rocco#test");//？后面表示参数，#后面表示锚点
            //查看协议
            System.out.println("协议:" + url.getProtocol());//协议:http
            //查看主机
            System.out.println("主机:"+url.getHost());//主机:www.imooc.com
            //查看端口
            //如果未指定端口号，则使用默认的端口号，此时getPort()方法返回值为-1
            System.out.println("端口:" +url.getPort());//端口:-1
            //文件路径
            System.out.println("文件路径:"+url.getPath());//文件路径:/index.html
            //文件名
            System.out.println("文件名:"+url.getFile());//文件名:/index.html?username=rocco
            //相对路径
            System.out.println("相对路径:"+url.getRef());//相对路径:test
            //查询字符串
            System.out.println("查询字符串:"+url.getQuery());//查询字符串:username=rocco
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

openStream类可以用来读取网站资源：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * 测试openStream类来读取网站资源
 */
public class TestopenStream {
    public static void main(String[] args) {
        try {
            //创建一个URL实例
            URL url = new URL("http://www.baidu.com");
            //通过URL的openStream方法获取URL对象所表示的资源的字节输入流
           InputStream is = url.openStream();
            //将字节输入流转换为字符输入流
            InputStreamReader isr =  new InputStreamReader(is);
            //为字符输入流添加缓冲
            BufferedReader br = new BufferedReader(isr);
            //读取数据
            String data = br.readLine();
            while (data != null){//循环读取数据
                System.out.println(data);
                data = br.readLine();
            }
            //关闭
            br.close();
            isr.close();
            is.close();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.TCP编程

3.1.Socket简介

TCP协议是面向链接的，可靠的，有序的，以字节流的方式发送数据

基于TCP协议是实现网络通信的类有两种：
客户端的Socket类
服务器端的ServerSocket类
Socket通信模型：

Socket通信实现步骤：
1.创建ServerSocket和Socket
2.打开连接到Socket的输入/输出流
3.按照协议对Socket进行读/写操作
4.关闭输入/输出流，关闭Socket

3.2.编程基于TCP的Socket通信之服务器端

根据1中的实现步骤，在Socket的服务端也是按照一下的顺序来写：
1.创建ServerSocket对象，绑定监听端口
2.通过accept()方法监听客户端请求
3.连接建立后，通过输入流读取客户端发送的请求信息
4.通过输出流向客户端发送响应信息
5.关闭相关资源

客户端也是对应的实现步骤：
1.创建Socket对象，指明需要连接的服务器的地址和端口号
2.连接建立后，通过输出流向服务器端发送请求信息
3.通过输入流获取服务器响应的信息
4.关闭相关资源

3.3.编程基于TCP的Socket通信之客户端

用一个案例来说明，我们模拟一个用户登录行为，从客户端向服务端发送登录请求。我们先写服务端，然后写客户端。
服务端：

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

/**
 * 基于TCP的Socket实现客户登录
 * 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.创建一个服务器端的Socket,即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8888);
            //2.调用accept()方法开始监听，等待客户端的连接
            System.out.println("****服务器即将启动，等待客户端的链接******");
            Socket socket = serverSocket.accept();
            //3.获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();//字节输入流
            InputStreamReader isr = new InputStreamReader(is);//将字节流转换为字符流
            BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲
            String info = null;
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4.关闭资源
            br.close();
            isr.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：

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

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("localhost", 8888);//因为是在本地主机上，所以IP地址可以指定为127.0.0.1或者localhost
            //2.获取输出流，向服务器端发送信息

            OutputStream os = socket.getOutputStream();//字节流输出
            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：admin; 密码：123");
            pw.flush();
            socket.shutdownOutput();//关闭输出流

            //3.关闭资源
            pw.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

3.4.完善用户登录之服务器响应客户端

上面的案例中，服务端接受了客户端的信息，但是服务器并没有响应客户端，也就是说客户端没有接收到来自服务端的信息，这里我们再改进一下。
服务端响应客户端我们需要用输出流
在上面的案例上做修改，只需要在服务器端添加一个输出流用来响应客户端请求；在客户端添加一个获取输入流，接收服务器端的信息，并打印出来

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

/**
 * 基于TCP的Socket实现客户登录
 * 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.创建一个服务器端的Socket,即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8888);
            //2.调用accept()方法开始监听，等待客户端的连接
            System.out.println("****服务器即将启动，等待客户端的链接******");
            Socket socket = serverSocket.accept();
            //3.获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();//字节输入流
            InputStreamReader isr = new InputStreamReader(is);//将字节流转换为字符流
            BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲
            String info = null;
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4.获取输出流，响应客户端请求
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);//包装为打印流
            pw.write("欢迎您！");
            pw.flush();


            //5.关闭资源
            pw.close();
            os.close();
            br.close();
            isr.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("localhost", 8888);//因为是在本地主机上，所以IP地址可以指定为127.0.0.1或者localhost
            //2.获取输出流，向服务器端发送信息

            OutputStream os = socket.getOutputStream();//字节流输出
            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：admin; 密码：123");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3.获取输入流，并读取服务器响应的信息
            InputStream is = socket.getInputStream();
            BufferedReader br= new BufferedReader(new InputStreamReader(is));//包装为字符流，并添加缓冲
            String info = null;
            while ((info=br.readLine())!=null){
                System.out.println("我是客户端，服务器说："+info);
            }
            
            //3.关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

3.5.使用多线程实现多客户端的通信

上面的案例是一个客户端和一个服务端的请求，通常情况下是多个客户端对一个服务器端的请求，所以这个时候需要使用多线程对服务器端进行改进。
改进的步骤为：
1.服务器端创建ServerSocket，循环调用accept()等待客户端连接
2.客户端创建一个Socket并请求和服务器端的连接
3.服务器端接受客户端请求，创建Socket与该客户端建立专线连接
4.建立连接的两个socket在一个单独的线程上对话
5.服务器端继续等待新的连接

我们在上一个案例中修改，只需要修改服务端，为服务端添加多线程处理类并在服务端类中调用就可以

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

/**
 * 基于TCP的Socket实现客户登录
 * 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.创建一个服务器端的Socket,即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(8888);
            Socket socket = null;
            System.out.println("****服务器即将启动，等待客户端的链接******");
            //记录客户端数量
            int count = 0;
            while (true){
                //调用accept()方法开始监听，等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新线程
                ServerThread serverThread = new ServerThread(socket);
                //启动线程
                serverThread.start();

                count++;//统计客户端数量
                System.out.println("客户端的数量："+count);
                InetAddress address = socket.getInetAddress();
                System.out.println("当前客户端的IP："+address);
            }

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

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

/**
 * 服务器端线程处理类
 */
public class ServerThread extends Thread{
    //和本线程性相关的Socket
    Socket socket = null;
    public ServerThread(Socket socket){
        this.socket = socket;
    }


    //线程执行的操作，响应客户端的请求
    public void run() {
        //3.获取输入流，并读取客户端信息
        InputStream is = null;//字节输入流
        InputStreamReader isr = null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            is = socket.getInputStream();
            isr = new InputStreamReader(is);//将字节流转换为字符流
            br = new BufferedReader(isr);//为输入流添加缓冲
            String info = null;
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //获取输出流，响应客户端请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);//包装为打印流
            pw.write("欢迎您！");
            pw.flush();

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

            try {

                //关闭资源
                if (pw!=null){
                    pw.close();
                }
                if (os!=null){
                    os.close();
                }
               if (br!=null){
                   br.close();
               }
               if (isr!=null){
                   isr.close();
               }
               if (is!=null){
                   is.close();
               }
               if (socket!=null){
                   socket.close();
               }

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


    }
}

4.UDP编程

UDP协议（用户数据报协议）是无连接，不可靠，无序的。以数据包作为数据传输的载体

即在进行数据传输时，首先需要将要传输的数据定义成数据报(Datagram)，在数据报中指明数据所要到达的Socket(主机地址和端口号),然后再将数据报发送出去

UDP编程我们常用的两个类是：
DatagramPacket：表示数据报包
DatagramSocket：进行端到端通信的类

4.1.编程基于UDP的Socket通信之服务端

我们同样用UDP协议来实现登录功能。
服务器端实现步骤：
1.创建DatagramSocket，指定端口号
2.创建DatagramPacket，用于接收客户端发送的数据
3.接受客户端发送的数据信息
4.读取数据

客户端实现步骤：
1.定义发送信息（内容，地址，端口号等）
2.创建DatagramPacket，包含将要发送的信息
3.创建DatagramSocket
4.发送数据

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

/**
 * C服务器端，实现基于UDP的用户登录
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket，指定端口号
        DatagramSocket socket = new DatagramSocket(8800);
        //2.创建DatagramPacket,用于接收客户端发送的数据
        byte[] data = new byte[1024];
        DatagramPacket packet=new DatagramPacket(data, data.length);
        //3.接受客户端发送的数据信息
        System.out.println("****服务器即将启动，等待客户端的链接******");
        socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
        //4.读取数据
        String info = new String(data,0,packet.getLength());
        System.out.println("我是服务器，客户端说："+info);
    }
}

4.2.编程基于UDP的Socket通信之客户端

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

/**
 * 客户端
 */
public class UDPClient {
    public static void main(String[] args) throws IOException {
        //1.定义发送信息（内容，地址，端口号等）
        InetAddress address = InetAddress.getByName("localhost");
        int port = 8800;
        byte[] data = "用户名：admin; 密码：123".getBytes();
        //2.创建DatagramPacket，包含将要发送的信息
        DatagramPacket packet = new DatagramPacket(data,data.length,address,port);
        //3.创建DatagramSocket
        DatagramSocket socket = new DatagramSocket();
        //4.发送数据
        socket.send(packet);
    }

}

4.3.服务器端响应客户端

再次改进上面的例子，需要服务器端响应客户端。这个时候需要在服务器端添加“向客户端响应数据”模块，也需要在客户端中添加“接收服务器端响应的数据”
代码如下：

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

/**
 * C服务器端，实现基于UDP的用户登录
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        /**
         * 服务器端接收信息
         */
        //1.创建DatagramSocket，指定端口号
        DatagramSocket socket = new DatagramSocket(8800);
        //2.创建DatagramPacket,用于接收客户端发送的数据
        byte[] data = new byte[1024];
        DatagramPacket packet=new DatagramPacket(data, data.length);
        //3.接受客户端发送的数据信息
        System.out.println("****服务器即将启动，等待客户端的链接******");
        socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
        //4.读取数据
        String info = new String(data,0,packet.getLength());
        System.out.println("我是服务器，客户端说："+info);

        /**
         * 向客户端响应数据
         */
        //1.定义客户端的地址，端口号，数据
        InetAddress address = packet.getAddress();
        int port = packet.getPort();
        byte[] data2 = "欢迎您！".getBytes();
        //2.创建数据报，包含响应的数据信息
        DatagramPacket packet2 = new DatagramPacket(data2, data2.length,address,port);
        //3.响应客户端
        socket.send(packet2);
        //4.关闭资源
        socket.close();
    }
}

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

/**
 * 客户端
 */
public class UDPClient {
    public static void main(String[] args) throws IOException {
        /**
         * 向服务器端发送信息
         */
        //1.定义发送信息（内容，地址，端口号等）
        InetAddress address = InetAddress.getByName("localhost");
        int port = 8800;
        byte[] data = "用户名：admin; 密码：123".getBytes();
        //2.创建DatagramPacket，包含将要发送的信息
        DatagramPacket packet = new DatagramPacket(data,data.length,address,port);
        //3.创建DatagramSocket
        DatagramSocket socket = new DatagramSocket();
        //4.发送数据
        socket.send(packet);

        /**
         * 接收服务器端响应的数据
         */
        //1.创建数据报，用于接收服务器端相应的数据
        byte[] data2 = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(data2,data2.length);
        //2.接收服务器端相应的数据
        socket.receive(packet2);
        //3.读取数据
        String reply = new String(data2,0,packet2.getLength());
        System.out.println("我是客户端，服务器说："+reply);
        //4.关闭资源
        socket.close();
    }

}

5.经验和技巧

还需要注意几个问题：
1.多线程的优先级

在TCP/UDP多线程环境下，未设置优先级可能会导致运行时速度非常慢，可降低优先级。

2.是否关闭输出流和输入流

对于同一个socket，如果关闭了输出流，则与该输出流关联的Socket也会被关闭，所以一般不用关闭流，直接关闭Socket即可

3.使用TCP通信传出对象

上面的例子中发送信息都是用字符串来发送的，但是在实际工作中都是使用对象来传输，例如将登录信息封装为一个user对象

4.socket编程传递文件

可以通过输入输出流来读取文件内容，并发送出去