关于java:JavaSE第23篇网络编程

外围概述：在互联网时代，咱们所利用的大部分软件都是基于网络为根底的，那么软件之间是如何通过网络通信的呢？为什么咱们通过浏览器输出网址就能够看到网页？本篇咱们将会学习网络编程，让咱们可能从编程角度更底层的更好的了解软件之间的通信流程。

第一章：网络编程根底

1.1-软件结构（理解）

C/S构造

C/S构造 ：全称为Client/Server构造，是指客户端和服务器构造。常见程序有ＱＱ、迅雷等软件。

B/S构造

B/S构造：全称为Browser/Server构造，是指浏览器和服务器构造。常见浏览器有谷歌、火狐等。

两种架构各有劣势，然而无论哪种架构，都离不开网络的反对。网络编程，就是在肯定的协定下，实现两台计算机的通信的程序。

1.2-网络通信协定（理解）

网络通信协定：通信协议是对计算机必须恪守的规定，只有恪守这些规定，计算机之间能力进行通信。这就 好比在路线中行驶的汽车肯定要恪守交通规则一样，协定中对数据的传输格局、传输速率、传输步骤等做了对立规定，通信单方必须同时恪守，最终实现数据交换。

TCP/IP协定： 传输控制协议/因特网互联协定( Transmission Control Protocol/Internet Protocol)，是Internet最根本、最宽泛的协定。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的规范。它的外部蕴含一系列的用于解决数据通信的协定，并采纳了4层的分层模型，每一层都呼叫它的下一层所提供的协定来实现本人的需要。

1.3-协定分类（理解）

通信的协定还是比较复杂的， java.net 包中蕴含的类和接口，它们提供低层次的通信细节。咱们能够间接应用这些类和接口，来专一于网络程序开发，而不必思考通信的细节。

TCP

TCP：传输控制协议 (Transmission Control Protocol)。TCP协定是面向连贯的通信协议，即传输数据之前，在发送端和接收端建设逻辑连贯，而后再传输数据，它提供了两台计算机之间牢靠无差错的数据传输。

三次握手：TCP协定中，在发送数据的筹备阶段，客户端与服务器之间的三次交互，以保障连贯的牢靠。

1. 第一次握手，客户端向服务器端收回连贯申请，期待服务器确认。
2. 第二次握手，服务器端向客户端回送一个响应，告诉客户端收到了连贯申请。
3. 第三次握手，客户端再次向服务器端发送确认信息，确认连贯。整个交互过程如下图所示。

实现三次握手，连贯建设后，客户端和服务器就能够开始进行数据传输了。因为这种面向连贯的个性，TCP协定能够保障传输数据的平安，所以利用非常宽泛，例如下载文件、浏览网页等。

UDP

用户数据报协定(User Datagram Protocol)。UDP协定是一个面向无连贯的协定。传输数据时，不须要建设连贯，不论对方端服务是否启动，间接将数据、数据源和目的地都封装在数据包中，间接发送。每个数据包的大小限度在64k以内。它是不牢靠协定，因为无连贯，所以传输速度快，然而容易失落数据。日常利用中,例如视频会议、QQ聊天等。

1.4-网络编程三要素（理解）

协定

协定：计算机网络通信必须恪守的规定，曾经介绍过了，不再赘述。

IP地址

什么是IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做惟一的编号。如果咱们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

IP地址的分类：

• IPv4：是一个32位的二进制数，通常被分为4个字节，示意成 a.b.c.d 的模式，例如 192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多能够示意42亿个。
• IPv6：因为互联网的蓬勃发展，IP地址的需求量愈来愈大，然而网络地址资源无限，使得IP的调配越发缓和。有材料显示，寰球IPv4地址在2011年2月调配结束。 为了扩充地址空间，拟通过IPv6从新定义地址空间，采纳128位地址长度，每16个字节一组，分成8组十六进 制数，示意成 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 ，号称能够为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

查看本机IP地址，在控制台输出： ipconfig

查看网络是否连通，在控制台输出：

ping 空格 IP地址ping 220.181.57.216【非凡的IP地址】本机IP地址： 127.0.0.1 、 localhost 。

端口号

网络的通信，实质上是两个过程（应用程序）的通信。每台计算机都有很多的过程，那么在网络通信时，如何辨别这些过程呢？

如果说IP地址能够惟一标识网络中的设施，那么端口号就能够惟一标识设施中的过程（应用程序）了。

端口号：用两个字节示意的整数，它的取值范畴是0-65535。其中，0~1023之间的端口号用于一些出名的网络服务和利用，一般的应用程序须要应用1024以上的端口号。如果端口号被另外一个服务或利用所占用，会导致以后程序启动失败。

利用 协定 + IP地址 + 端口号 三元组合，就能够标识网络中的过程了，那么过程间的通信就能够利用这个标识与其它过程进行交互。

第二章：TCP通信程序

2.1-TCP通信程序介绍（理解）

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格辨别为客户端（Client）与服务端（Server）。

两端通信时步骤：

1. 服务端程序，须要当时启动，期待客户端的连贯。
2. 客户端被动连贯服务器端，连贯胜利能力通信。服务端不能够被动连贯客户端。

在Java中，提供了两个类用于实现TCP通信程序：

• 客户端：java.net.Socket 类示意。创立Socket对象，向服务端收回连贯申请，服务端响应申请，两者建设连贯开始通信。
• 服务端：java.net.ServerSocket 类示意。创立ServerSocket对象，相当于开启一个服务，并期待客户端的连贯。

2.2-Socket类（重要）

Socket 类：该类实现客户端套接字，套接字指的是两台设施之间通信的端点。

构造方法

public Socket(String host, int port) :创立套接字对象并将其连贯到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

回送地址(127.x.x.x) 是本机回送地址（Loopback Address），次要用于网络软件测试以及本地机过程间通信，无论什么程序，一旦应用回送地址发送数据，立刻返回，不进行任何网络传输。

Socket client = new Socket("127.0.0.1", 6666);

成员办法

• public InputStream getInputStream()： 返回此套接字的输出流。

  • 如果此Scoket具备相关联的通道，则生成的InputStream 的所有操作也关联该通道。
  • 敞开生成的InputStream也将敞开相干的Socket。

• public OutputStream getOutputStream() ： 返回此套接字的输入流。

  • 如果此Scoket具备相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
  • 敞开生成的OutputStream也将敞开相干的Socket。

• public void close() ：敞开此套接字。

  • 一旦一个socket被敞开，它不可再应用。
  • 敞开此socket也将敞开相干的InputStream和OutputStream 。

• public void shutdownOutput() ： 禁用此套接字的输入流。

  • 任何先前写出的数据将被发送，随后终止输入流

2.3-ServerSocket类（重要）

ServerSocket 类：这个类实现了服务器套接字，该对象期待通过网络的申请。

构造方法

构造方法：public ServerSocket(int port)：应用该构造方法在创立ServerSocket对象时，就能够将其绑定到一个指 定的端口号上，参数port就是端口号。

ServerSocket server = new ServerSocket(6666);

成员办法

成员办法：public Socket accept()：侦听并承受连贯，返回一个新的Socket对象，用于和客户端实现通信。该办法 会始终阻塞直到建设连贯。

2.4-简略的TCP网络程序（重要）

TCP通信剖析

1. 【服务端】启动,创立ServerSocket对象，期待连贯。
2. 【客户端】启动,创立Socket对象，申请连贯。
3. 【服务端】接管连贯,调用accept办法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。
6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
7. 【客户端】Scoket对象，获取InputStream，解析回写数据。
8. 【客户端】开释资源，断开连接

客户端向服务端发送数据

客户端代码

public class ClientTCP {    public static void main(String[] args) throws Exception {        System.out.println("客户端 发送数据");        // 1.创立 Socket ( ip , port ) , 确定连贯到哪里.        Socket client = new Socket("localhost", 6666);        // 2.获取流对象 . 输入流        OutputStream os = client.getOutputStream();        // 3.写出数据.        os.write("你好么? tcp ,我来了".getBytes());        // 4. 敞开资源 .        os.close();        client.close();    }}

服务端代码

public class ServerTCP {    public static void main(String[] args) throws IOException {        System.out.println("服务端启动 , 期待连贯 .... ");        // 1.创立 ServerSocket对象，绑定端口，开始期待连贯        ServerSocket ss = new ServerSocket(6666);        // 2.接管连贯 accept 办法, 返回 socket 对象.        Socket server = ss.accept();        // 3.通过socket 获取输出流        InputStream is = server.getInputStream();        // 4.一次性读取数据          // 4.1 创立字节数组        byte[] b = new byte[1024];          // 4.2 据读取到字节数组中.        int len = is.read(b)；        // 4.3 解析数组,打印字符串信息        String msg = new String(b, 0, len);        System.out.println(msg);        //5.敞开资源.        is.close();        server.close();    }}

服务端向客户端回写数据

服务端代码

public class ClientTCP {    public static void main(String[] args) throws Exception {        System.out.println("客户端 发送数据");        // 1.创立 Socket ( ip , port ) , 确定连贯到哪里.        Socket client = new Socket("localhost", 6666);        // 2.通过Scoket,获取输入流对象         OutputStream os = client.getOutputStream();        // 3.写出数据.        os.write("你好么? tcp ,我来了".getBytes());          // ==============解析回写=========================          // 4. 通过Scoket,获取 输出流对象          InputStream in = client.getInputStream();          // 5. 读取数据数据          byte[] b = new byte[100];          int len = in.read(b);          System.out.println(new String(b, 0, len));        // 6. 敞开资源 .          in.close();        os.close();        client.close();    }}

客户端代码

public class ServerTCP {    public static void main(String[] args) throws IOException {        System.out.println("服务端启动 , 期待连贯 .... ");        // 1.创立 ServerSocket对象，绑定端口，开始期待连贯        ServerSocket ss = new ServerSocket(6666);        // 2.接管连贯 accept 办法, 返回 socket 对象.        Socket server = ss.accept();        // 3.通过socket 获取输出流        InputStream is = server.getInputStream();        // 4.一次性读取数据          // 4.1 创立字节数组        byte[] b = new byte[1024];          // 4.2 据读取到字节数组中.        int len = is.read(b)；        // 4.3 解析数组,打印字符串信息        String msg = new String(b, 0, len);        System.out.println(msg);          // =================回写数据=======================          // 5. 通过 socket 获取输入流           OutputStream out = server.getOutputStream();          // 6. 回写数据           out.write("我很好,谢谢你".getBytes());          // 7.敞开资源.          out.close();        is.close();        server.close();    }}

第三章：文件上传案例

3.1-文件上传剖析

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

3.2-客户端程序实现

public static void main(String[] args) throws IOException {    // 1.创立流对象    // 1.1 创立输出流,读取本地文件    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));    // 1.2 创立输入流,写到服务端    Socket socket = new Socket("localhost", 6666);    BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());    //2.写出数据.    byte[] b  = new byte[1024 * 8 ];    int len ;    while (( len  = bis.read(b))!=-1) {        bos.write(b, 0, len);    }    // 敞开输入流,告诉服务端,写出数据结束    socket.shutdownOutput();    System.out.println("文件发送结束");    // 3. =====解析回写============    InputStream in = socket.getInputStream();    byte[] back = new byte[20];    in.read(back);    System.out.println(new String(back));    in.close();        // 4.开释资源    socket.close();    bis.close();}

3.3-文件上传单线程服务器实现

public static void main(String[] args) throws IOException {        System.out.println("服务器 启动.....  ");        // 1. 创立服务端ServerSocket        ServerSocket serverSocket = new ServerSocket(6666);        // 2. 循环接管,建设连贯        Socket accept = serverSocket.accept();            /*             *3. socket对象进行读写操作               */        try {                //3.1 获取输出流对象                BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());                //3.2 创立输入流对象, 保留到本地 .                FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");                BufferedOutputStream bos = new BufferedOutputStream(fis);                // 3.3 读写数据                byte[] b = new byte[1024 * 8];                int len;                while ((len = bis.read(b)) != -1) {                    bos.write(b, 0, len);                }                // 4.=======信息回写===========================                System.out.println("back ........");                OutputStream out = accept.getOutputStream();                out.write("上传胜利".getBytes());                out.close();                //================================                //5. 敞开 资源                bos.close();                bis.close();                accept.close();                System.out.println("文件上传已保留");        } catch (IOException e) {            e.printStackTrace();        }    }}

3.4-文件上传多线程服务器实现

文件上传的案例中，服务器只能为客户端服务器一次，之后服务器端程序就会完结。而咱们必须做到让服务器程序不能完结，时时刻刻都要为客户端服务。而且同时能够为多个客户端提供服务器，做到一个客户端就要开启一个信新的线程。

public static void main(String[] args) throws IOException{    System.out.println("服务器 启动.....  ");    // 1. 创立服务端ServerSocket    ServerSocket serverSocket = new ServerSocket(6666);    // 2. 循环接管,建设连贯    while (true) {        Socket accept = serverSocket.accept();        /*        3. socket对象交给子线程解决,进行读写操作        Runnable接口中,只有一个run办法,应用lambda表达式简化格局        */        new Thread(() -> {            try{            //3.1 获取输出流对象            BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());            //3.2 创立输入流对象, 保留到本地 .            FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");            BufferedOutputStream bos = new BufferedOutputStream(fis);            // 3.3 读写数据            byte[] b = new byte[1024 * 8];            int len;            while ((len = bis.read(b)) != -1) {            bos.write(b, 0, len);            }            // 4.=======信息回写===========================            System.out.println("back ........");            OutputStream out = accept.getOutputStream();            out.write("上传胜利".getBytes());            out.close();            //================================            //5. 敞开 资源            bos.close();            bis.close();            accept.close();            System.out.println("文件上传已保留");            } catch (IOException e) {            e.printStackTrace();            }        }).start();    }}

3.5-文件上传服务器实现优化

频繁的创立线程会减少系统资源的开销，能够利用线程池进行再次优化。

public static void main(String[] args)  throws IOException{    System.out.println("服务器 启动.....  ");    ServerSocket serverSocket = new ServerSocket(6666);    //创立10个线程的线程池    ExecutorService executorService = Executors.newFixedThreadPool(10);        while (true) {        Socket accept = serverSocket.accept();        //提交线程执行的工作        executorService.submit(()->{            try{            BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());            FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");            BufferedOutputStream bos = new BufferedOutputStream(fis);            byte[] b = new byte[1024 * 8];            int len;            while ((len = bis.read(b)) != -1) {            bos.write(b, 0, len);            }            System.out.println("back ........");            OutputStream out = accept.getOutputStream();            out.write("上传胜利".getBytes());            out.close();            bos.close();            bis.close();            accept.close();            System.out.println("文件上传已保留");            } catch (IOException e) {                e.printStackTrace();            }        });    }}

第四章：模仿B/S服务器

模仿网站服务器，应用浏览器拜访本人编写的服务端程序，查看网页成果。

4.1-案例剖析

我的项目中有一个web我的项目，咱们写服务端代码，而后通过浏览器输出地址127.0.0.1:8888/web/index.html

• 筹备页面数据，web文件夹。

  • 蕴含网页html文件
  • 蕴含图片
  • 蕴含css样式表
• 咱们模仿服务器端，ServerSocket类监听端口，应用浏览器拜访，查看网页成果

4.2-HTTP协定

案例中需应用浏览器查看成果，浏览器和服务器之间是遵循HTTP协定的，咱们先对HTTP协定进行简略的介绍，在前期JavaWeb相干篇幅中再详解解释。

• HTTP协定，称为超文本传输协定。
• 规定了客户端浏览器和服务器之间的协定。
• HTTP协定是TCP网络通信模型中应用层的协定。
• 客户端浏览器被动向服务器发动申请，服务器收到后进行响应。

• 客户端申请

  • 客户端在申请的信息的第一行中，携带了客户端想要申请的资源门路。

• 服务器端响应

  • 响应中必须告知客户端响应的后果。
  • 200状态码示意响应胜利。
  • Content-Type:text/html 告知浏览器响应的内容是文本/网页内容。

4.3-代码实现

代码

public class WebSever {  public static void main(String[] args) throws IOException {    // 创立ServerSocket对象   ServerSocket server = new ServerSocket(8888);   while (true){     new Thread(new Runnable() {       @Override       public void run() {        try{          // 获取socket对象          Socket socket = server.accept();          // 读取接管的内容          BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));          String line = reader.readLine(); // GET /web/index.html HTTP/1.1          String path = line.split(" ")[1].substring(1);          // 创立本地字节输出流          FileInputStream fis = new FileInputStream("day09_Socket\\" +path);          // 创立网络输入流          OutputStream os = socket.getOutputStream();          // 写入HTTP协定响应头,固定写法          os.write("HTTP/1.1 200 OK\r\n".getBytes());          os.write("Content‐Type:text/html\r\n".getBytes());          // 必须要写入空行,否则浏览器不解析          os.write("\r\n".getBytes());          int len = 0;          byte[]bts = new byte[1024];          while((len=fis.read(bts))!=-1){            os.write(bts,0,len);          }          // 敞开资源          os.close();          fis.close();          reader.close();          socket.close();        } catch (IOException e){          e.printStackTrace();        }       }     }).start();   }  }}

成果

浏览器输出地址127.0.0.1:8888/web/index.html拜访