网络编程(客户端与服务端的连接)

1. 网络通信协议

1.1 协议和七层模型

要使计算机连成的网络能够互通信息，需要对数据传输速率、传输代码、代码结构、传输控制步骤、出错控制等制定一组标准，这一组共同遵守的通信标准就是网络通信协议，不同的计算机之间必须使用相同的通讯协议才能进行通信。

​ 七层模型，也称为OSI（Open System Interconnection）参考模型，是国际标准化组织（ISO）制定的一个用于计算机或通讯系统间互联的标准体系。它是一个七层的、抽象的模型体，不仅包括一系列抽象的术语或概念，也包括具体的协议。 ​ ISO 就是 Internationalization Standard Organization（国际标准组织）。

* 应用层:

​ 应用程序之间如何相互传递报文,比如HTTP协议,FTP协议

* 传输层

​ 传输层的作用是为两台主机之间的"应用进程"提供端到端的逻辑通信,比如TCP协议

* 网络层互联层

网络层互联层提供了主机到主机的通信,将传输层产生的数据包封装成分组数据包发送到目标主机,并提供路由选择能力. IP协议是网络层的主要协议,TCP和UDP都是用IP协议作为网络层协议.这一层的主要作用是给包加上源地址和目标地址,将数据包传送到目标地址.
  
* 网络访问层

网络访问层也可以称为网络接口层,以太网,WIFI,蓝牙就是工作在这一层,网络访问层提供了主机连接到物理网络需要的硬件和相关协议

1.2 TCP/IP协议

在Internet中TCP/IP协议是使用最为广泛的通讯协议。TCP/IP是英文Transmission Control Protocol/Internet Protocol的缩写，意思是“传输控制协议/网际协议”

**TCP/IP协议**(定义了电子设备（比如计算机）如何连入因特网，以及数据如何在它们之间传输的标准)：

​ Internet上不同系统之间互联的一组协议

​ 为分散和不同类型的硬件提供通用的编程接口。

​ TCP/IP协议使Internet尽可能成为一个分散、无序的网络。

​ TCP是基于(面向)连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。

​ TCP协议建立连接需要三次会话(握手)

①客户端请求建立连接(SYN)，并且发送出序号。

②服务端接受到信号，即有确认号（ACK）,此时并同样返回请求序号Seq

③客户端接受到信号，即有确认号（ACK），连接已经建立。

为什么是三次:

1、在第一次通信过程中，客户端向服务器发送信息之后，服务器收到信息后可以确认自己的收信能力和客户端的发信能力没有问题。

2、在第二次通信中，服务器向客户端发送信息之后，客户端可以确认自己的发信能力和服务器的收信能力没有问题，但是服务器不知道自己的发信能力到底如何，所以就需要第三次通信。

3、在第三次通信中，客户端向服务器发送信息之后，服务器就可以确认自己的发信能力没有问题。

IP地址：网络中每台计算机的一个标识号

​ 是一个逻辑地址.在实际中可以使用127.0.0.1表示本机，或者直接使用localhost代表本机

​ IP地址使用32位长度二进制数据表示，一般在实际中看到的大部分IP地址都是以十进制的数据形式表示的，如：192.168.1.3。

​ IP地址分类：

​ IP地址分为5类，A类保留给政府机构，B类分配给中等规模的公司，C类分配给任何需要的人，D类用于组播，E类用于实验，各类可容纳的地址数据不同。

端口号**：具有网络功能的应用软件的标识号

​ 端口是一个软件结构，被客户程序或服务程序用来发送和接收数据，一台服务器有256*256个端口。

​ 0-1023是公认端口号，即已经公认定义或为将要公认定义的软件保留的

​ 1024-65535是并没有公共定义的端口号，用户可以自己定义这些端口的作用。

​ 端口与协议有关：TCP和UDP的端口互不相干

2. 网络通信的实现

2.1 socket编程

套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。

​ 当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。

​ java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

2.2 TCP协议通信

TCP是一个面向连接的,可靠的,基于字节流的传输层协议.

面向连接: 所谓的连接,指的是客户端与服务器端的连接,在双方相互通信之前,TCP需要三次握手建立连接.

2.2.1 服务端编程

package cn.gl.no1;

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

/**
 * 服务端
 * @author Administrator
 *
 */
public class Server {

    public static void main(String[] args) {
        ServerSocket server = null;
        Socket socket = null;
        try {
            //准备服务器端用的通讯对象（套接字）,指明端口号为8888
            server = new ServerSocket(8888);
            //到指定端口去阻塞监听,一旦有客户端请求发送过来，那么立即自动与客户端建立连接
            socket = server.accept();
            System.out.println("服务器端准备ok");
            //我要发送到客户端的内容
            String msg = "你好,我是服务器，这是我的第一次通讯,请问你收到了吗";
            OutputStream os = socket.getOutputStream();//准备输出对象
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
            bw.write(msg);
            bw.newLine();
            bw.flush();
            //接收客户端发送的信息
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String reply = br.readLine();
            System.out.println("我是服务器，接收到信息："+reply);

            br.close();
            is.close();
            bw.close();
            os.close();
            socket.close();
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2.2 客户端实现

package cn.gl.no1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 客户端
 * @author Administrator
 *
 */
public class Client {

    public static void main(String[] args) {
        Socket socket = null;
        try {
            socket = new Socket("localhost", 8888);
            System.out.println("客户端准备完成");

            //客户端开始接受请求
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg = br.readLine();
            System.out.println("我是客户端，接收到信息："+msg);

            //客户端接收到服务器端的信息之后，需要反馈信息给服务器
               //客户端想要反馈给服务器端的信息 
            String reply = "我是客户端，收到你的信息，这是我的反馈";
            OutputStream os = socket.getOutputStream();//准备客户端的输出流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
            bw.write(reply);
            bw.newLine();

            bw.flush();
            bw.close();
            os.close();
            br.close();
            is.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.3 UDP协议通信

UDP是一个面向无连接,不可靠的传输层协议.

需要用到两个类：DatagramSocket,DatagramPacket

DatagramSocket类的作用：发送和接收数据包的套接字，不维护连接状态，不产生输入输出流

DatagramPacket类：数据包，封装了数据，数据长度

2.3.1 服务端编程

package cn.gl.no1;

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

public class Client1 {

    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            //参与通讯的两方，至少应该有一边指定端口号
            socket = new DatagramSocket();

            String msg = "我要发送的短信内容";
            //dp对象，是用来把要发送的信息打成一个数据包
            //数据长度不能超过64K
            //构造中可以传递四个参数:
            //第一个参数，表示要发送的内容，需要转换成一个byte数组
            byte [] b = msg.getBytes();
            //第二个参数，表示发送内容的字节数
            int len = b.length;
            //第三个参数，表示IP地址封装的一个对象，类型是InetAddress,是接收方的地址
            InetAddress ia = InetAddress.getByName("localhost");
            //第四个参数，表示对方的端口号
            int port = 8888;
            DatagramPacket dp = new DatagramPacket(b, len, ia, port);

            socket.send(dp);

            byte [] bs = new byte[1024];
            int length = bs.length;
            DatagramPacket dpReceive = new DatagramPacket(bs, length);
            socket.receive(dpReceive);
            String reply = new String(bs,0,dpReceive.getLength());
            System.out.println("我是client1,收到信息："+reply);


            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.3.2 客户端实现

package cn.gl.no1;

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

public class Client2 {

    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(8888);

            //这里为了接收数据，也需要一个空的数据包
            //两个参数：
            //第一个参数，表示一个空的byte数组,用来接收信息内容
            byte [] b = new byte[1024];
            //第二个参数，表示数组长度
            int len = b.length;
            DatagramPacket dp = new DatagramPacket(b, len);
            //接收信息
            socket.receive(dp);
            String msg = new String(b,0,dp.getLength());
            System.out.println("我是Client2,接收到信息："+msg);

            String reply = "我很好，收到你的信息，很高兴，谢谢";
            byte [] bs = reply.getBytes();
            int length = bs.length;
            InetAddress ia = dp.getAddress();
            /*InetSocketAddress isa = (InetSocketAddress) dp.getSocketAddress();
            System.out.println("isa.getHostName():"+isa.getHostName());
            System.out.println("isa.getHostString():"+isa.getHostString());
            System.out.println("isa.getPort():"+isa.getPort());*/
            int port = dp.getPort();
            DatagramPacket dpReply = new DatagramPacket(bs, length, ia, port);        
            socket.send(dpReply);

            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}