1. 什么是计算机网络，计算机网络的作用？

a) 在物理位置上，多台计算机之间使用网线连接起来，就形成了计算机网络。
b) 网络分：局域网和广域网。
c) 计算机网络的作用就是“资源共享”。

2. 计算机网络编程指的是什么？

a) 使用一门计算机语言，实现计算机和计算机之间进行通信。
b) 例如java语言提供的java.net.*;如：Socket和ServerSocket。

3. 关于IP地址？

a) IP地址非常重要，因为IP是网络中每一台计算机的唯一标识。计算机之间进行通信完全靠IP地址进行连接。
b) 计算机和计算机之间通信每台计算机需要安装网卡和网卡驱动。
c) IP地址分为：IPV4和IPV6
i. IPV4目前用的比较多。例如：192.168.1.100
ii. IPV4计算机在存储的时候采用4个字节去存储。255.255.255.255
iii. IPV4最大大概可以表示4亿多台计算机。也就是说在广域网中最多有4亿多个真实IP。
d) 关于IP地址分类：A类网，B类网，C类网
i. A类网：网络ID号.主机号.主机号.主机号
ii. B类网：网络ID号.网络ID号.主机号.主机号
iii. C类网：网络ID号.网络ID号.网络ID号.主机号

4. 关于端口号PORT？

a) Oracle默认的端口是1521
b) Mysql默认的端口是3306
c) WEB网站默认的端口是80
d) Tomcat服务器默认的端口是8080
e) 端口号在计算机中是每一个服务的唯一标识。端口号在同一台计算机上不可以重复。

端口号取值范围：
一般用到的是1~65535。
其中0不使用，1-1023为系统端口，也叫BSD保留端口。
0-1023： BSD保留端口，也叫系统端口，这些端口只有系统特许的进程才能使用；
1024~65535为用户端口，又分为：BSD临时端口(1024-5000)和BSD服务器(非特权)端口(5001-65535)。其中：
1024-5000： BSD临时端口，一般的应用程序使用1024到4999来进行通讯；
5001-65535：BSD服务器(非特权)端口，用来给用户自定义端口。

5. 计算机之间通信需要协议？

a) 位于传输层的协议有：TCP、UDP
b) TCP和UDP区别？
i. TCP协议是面向有连接的协议。面向有连接的协议可以保证网络传输中不会丢失数据包。优点：不会丢失数据包。缺点：速度慢。
ii. UDP协议是面向无连接的协议。面向无连接的协议只负责发送数据，不管对方是否收到，或者是否丢失数据。优点：速度快。缺点：可能丢失数据。

6. 关于HTTP协议？

a) W3C组织定义的HTTP协议。
b) 生产浏览器（Browser）的厂商（微软，谷歌，Mozilla FireFox）都要遵循HTTP协议生产浏览器。
c) 生产服务器（Server）的厂商（IBM,BEA）都要遵循HTTP协议生产服务器。

7. 使用java实现计算机和计算机之间的通信？

a) Socket（客户端套接字）à插头（IP+PORT）
b) ServerSocket（服务器端套接字）à插座（PORT）

8. HTTP1.1协议的详细内容：

  1. GET / HTTP/1.1
  2. Accept: image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/msword, application/vnd.ms-excel, application/vnd.ms-powerpoint, */*
  3. Accept-Language: zh-cn
  4. User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)
  5. Accept-Encoding: gzip, deflate
  6. Host: 192.168.1.100:8888
  7. Connection: Keep-Alive
  8. 空白行
  9. 消息正文
  11. HTTP协议四部分组成：消息头，消息报头，空白行，消息正文

9. 客户端向服务器端发送数据

1、服务器端实现

  1. //1、服务器端实现
  2. class Server1 {
  3.     public static void main(String[] args) throws IOException {
  4.         System.out.println("服务器端启动，等待连接....");
  5.         //1.创建ServerSocket对象，绑定端口，开始等待连接
  6.         ServerSocket ss=new ServerSocket(6666);
  7.         //2.接收连接accept方法，返回socket对象
  8.         Socket server=ss.accept();
  9.         //3.通过Socket对象，获取输入流
  10.         InputStream is=server.getInputStream();
  11.         //4 一次性读取数据
  12.         //4.1 创建字节数组
  13.         byte[] b=new byte[1024];
  14.         //4.2 数据读取到字节数组中
  15.         int len=is.read(b);
  16.         //4.3 解析数组，打印字符串信息
  17.         String msg=new String(b,0,len);
  18.         System.out.println(msg);
  19.         //5.关闭资源
  20.         is.close();
  21.         server.close();
  22.     }
  23. }

2、客户端实现

  1.  class Client1 {
  2.     public static void main(String[] args) throws IOException {
  3.         System.out.println("客户端发送数据");
  4.         //1.创建Socket（ip,port），确定连接到哪里
  5.         Socket client=new Socket("127.0.0.1",6666);
  6.         //2.获取流对象.输出流
  7.         OutputStream os=client.getOutputStream();
  8.         //3.写出数据
  9.         os.write("TCP协议，我学会了！".getBytes());
  10.         //4.关闭资源
  11.         os.close();
  12.         client.close();
  13.     }
  14. }

10、服务器端向客户端回写数据

1、服务器端实现

  1. class Server2 {
  2.     public static void main(String[] args) throws IOException {
  3.         System.out.println("服务器启动，等待连接。。。");
  4.         //1.创建ServerSocket对象，绑定端口，开始等待连接
  5.         ServerSocket s=new ServerSocket(6666);
  6.         //2.接受连接accpet方法，返回Socket对象
  7.         Socket server = s.accept();
  8.         //3.通过Socket获取输入流
  9.         InputStream is = server.getInputStream();
  10.         //4 一次性读取数据
  11.         //4.1 创建数组对象
  12.         byte[] b=new byte[1024];
  13.         //4.2 读取数据到字节数组中
  14.         int len=is.read(b);
  15.         //4.3 解析数组，打印字符串信息
  16.         String msg=new String(b,0,len);
  17.         System.out.println("服务器接收到的数据："+msg);
  18.         //======回写数据==========
  19.         //5 通过socket获取输出流
  20.         OutputStream os = server.getOutputStream();
  21.         //6.回写数据
  22.         os.write("服务器回写数据".getBytes());
  23.         //7.关闭资源
  24.         os.close();
  25.         is.close();
  26.         server.close();
  27.     }
  28. }

2、客户端实现

  1. class Client2 {
  2.     public static void main(String[] args) throws IOException {
  3.         System.out.println("客户端 发送数据");
  4.         //1. 创建Socket（ip,port）,确定连接到哪里
  5.         Socket client=new Socket("127.0.0.1",6666);
  6.         //2.通过Socket对象，获取输出流对象
  7.         OutputStream os = client.getOutputStream();
  8.         //3.写出数据
  9.         os.write("客户端写数据了".getBytes());
  10.         //4.通过Socket，获取输入流对象
  11.         InputStream is = client.getInputStream();
  12.         //5.读取数据
  13.         byte[] b=new byte[1024];
  14.         int len=is.read(b);
  15.         System.out.println(new String(b,0,len));
  16.         //6.关闭资源
  17.         is.close();
  18.         os.close();
  19.         client.close();
  20.     }
  21. }

11、文件上传案例

文件上传分析图解：
1【客户端】输入流，从硬盘中读取文件数据到程序中。
2.【客户端】输出流，写出文件数据到服务器。
3.【服务器】输入流，读取文件数据到服务器程序。
4. 【服务器】输出流，写出文件数据到服务器硬盘中。
图片1.png

1、服务器端实现

  1. public class Demo04 {
  2.     public static void main(String[] args) throws IOException {
  3.         System.out.println("服务器端启动。。。");
  4.         //1 创建服务器端ServerSocket
  5.         ServerSocket ss=new ServerSocket(6666);
  6.         //2.服务端通过ServerSocket建立连接
  7.         Socket server= ss.accept();
  8.         //3.创建流对象
  9.         //3.1 获取输入流，读取文件数据
  10.         BufferedInputStream bis=new BufferedInputStream(server.getInputStream());
  11.         //3.2 创建输出流，保存到本地
  12.         BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("copy.jpg"));
  13.         //4.读写数据
  14.         byte[] b=new byte[1024*8];
  15.         int len;
  16.         while ((len=bis.read(b))!=-1){
  17.             bos.write(b,0,len);
  18.         }
  19.         //5.关闭资源
  20.         bis.close();
  21.         bos.close();
  22.         server.close();
  23.         System.out.println("文件已经上传");
  24.     }
  25. }

2、客户端实现

  1. public class Demo05 {
  2.     public static void main(String[] args) throws IOException {
  3.         //1.创建流对象
  4.         //1.1 创建输入流，读取本地文件
  5.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream("text.jpg"));
  6.         //1.2 创建输出流对象，写到服务器
  7.         Socket socket=new Socket("localhost",6666);
  8.         BufferedOutputStream bos=new BufferedOutputStream(socket.getOutputStream());
  9.         //2.写出数据
  10.         byte[] b=new byte[1024*8];
  11.         int len;
  12.         while ((len=bis.read(b))!=-1){
  13.             bos.write(b,0,len);
  14.             bos.flush();
  15.         }
  16.         System.out.println("文件发送完毕");
  17.         //释放资源
  18.         bis.close();
  19.         bos.close();
  20.         socket.close();
  21.     }
  22. }

12、信息回写分析图解：

1【客户端】输入流，从硬盘中读取文件数据到程序中。
2.【客户端】输出流，写出文件数据到服务器。
3.【服务器】输入流，读取文件数据到服务器程序。
4. 【服务器】输出流，写出文件数据到服务器硬盘中
5.【服务器】获取输出流，回写数据。
6.【客户端】获取输入流，解析回写数据。

图片2.png