1. 课前回顾:
  2.   1.序列化流(读写对象)
  3.   2.注意:如果想实现序列化,那么被序列化的类要实现Serializable接口
  4.   3.序列化流:ObjectOutputStream
  5.             writeObject(Object o)
  6.     反序列化流:ObjectInputStream
  7.              Object readObject()
  8.   4.注意:
  9.     a.为防止序列号冲突,我们将序列号定死:定义static final long
  10.     b.不能随便循环反序列化:EOFException
  11.       循环次数必须和存储对象的个数一样->将每个对象存到集合中
  12.   5.Properties
  13.     load(InputStream in)->将流中的数据加载到properties集合中
  14.   6.打印流:PrintStream
  15.     println:原样输出,自带换行
  16.     print:原样输出,不带换行
  18.     改变流向:System.setOut(打印流对象)
  19.   7.Lombok插件:@Data
  20.   8.正则表达式:有特殊规则的字符串
  21.     String中有一个方法,验证字符串是否符合正则表达式:boolean matches(正则表达式)
  22.     [0-9]: 表示0-9任意一个数字
  23.     [abc]: 表示a或者b或者c
  24.     \\d:相当于[0-9]
  25.     .:匹配任意字符
  26.     x+:x至少出现1次
  27.     x*:x出现任意次
  28.     x{n}:x出现必须是n次
  29.     x{n,}:x至少出现n次
  30.     x{n,m}:x出现n次到m次
  31.   9.单例模式:让一个类只产生一个对象
  32.     饿汉式:让对象马上产生,所以定义为private static的
  33.     懒汉式:什么时候用,什么时候new  ->需要双重检测锁
  34.   10.Commons-io:简化IO开发的工具类
  35.      IOUtils:
  36.         IOUtils.copy(InputStream in,OutputStream out)
  37.         IOUtils.closeQuietly(任意流对象)悄悄的释放资源
  38.      FileUtils:copyDirectoryToDirectory(File src,File dest)
  39.                writeStringToFile(File file,String str)
  40.                String readFileToString(File file)
  42. 今日内容:
  43.   1.会简单定义枚举,会调用枚举中的成员
  44.   2.了解软件架构
  45.   3.知道网络通信三要素
  46.   4.知道完成通信之前的三次握手
  47.   5.知道客户端和服务端完成交互的过程
  48.   6.会使用TCP完成简单的客户端和服务端交互

一.枚举

1.枚举介绍

  1. 1.当[对象]的个数是有限的,确定的,我们就可以定义为一个枚举类
  2.   当定义一组常量时,推荐使用枚举
  1.   枚举:
  2.     1.概述:引用数据类型
  3.           类  数组  接口  注解  [枚举]
  4.     2.关键字:enum->java.lang.Enum类，是所有枚举的父类。
  5.     3.枚举：成员很单一,里面一般都定义常量(默认的修饰符 public static final但是定义的时候写上报错)
  7.     4.特点:定义的常量都是这个枚举类的对象
  8.            一个枚举类中有多个对象(多例)
  9.     5.问题:我们定义出来的常量,数据类型应该是什么:本类类型
  10.     6.使用场景:一般用在表示状态上(如果用1234表示状态不太好,用枚举是最好的)
  11.         提交订单: 未付款  
  12.         提交订单: 已付款  
  13.         提交订单: 未发货  
  14.         提交订单: 已发货(发货中)
  15.         提交订单: 派件中
  16.         提交订单: 已签收
  18.      7.枚举中定义构造:(了解)
  19.           a.无参构造:默认权限修饰符是private
  20.           b.有参构造:private,要是赋值的话,我们可以利用常量直接赋值 :RED("红色")
  1. /*
  2.   Color叫 枚举类
  4.   枚举类中的常量叫枚举
  5.  */
  6. public enum Color {
  7.     RED,//Color RED = new Color()
  8.     GREEN,//Color GREEN = new Color()
  9.     YELLOW;//Color YELLOW = new Color()
  10. }
  1. public class Test01_Color {
  2.     public static void main(String[] args) {
  3.         Color red = Color.RED;
  4.         //System.out.println(red);
  5.         System.out.println(red.toString());
  6.     }
  7. }
  1. public enum State {
  2.     WEIFUKUAN("未付款"),//State WEIFUKUAN = new State()   State WEIFUKUAN = new State("未付款")
  3.     YIFUKUAN("已付款"),//State YIFUKUAN = new State()     State WEIFUKUAN = new State("已付款")
  4.     WEIFAHUO("未发货"),//State WEIFAHUO = new State()     State WEIFAHUO = new State("未发货")
  5.     YIFAHUO("已发货"),//State YIFAHUO = new State()       State YIFAHUO = new State("已发货")
  6.     YIQIANSHOU("已签收");//State YIQIANSHOU = new State() State YIQIANSHOU = new State("已签收")
  8.     private State(){
  10.     }
  12.     //定义成员变量
  13.     private String state;
  15.     private State(String state) {
  16.         this.state = state;
  17.     }
  19.     //提供一个get方法获取枚举值
  21.     public String getState() {
  22.         return state;
  23.     }
  24. }
  1. public class Test02_State {
  2.     public static void main(String[] args) {
  3.         State weifukuan = State.WEIFUKUAN;
  4.         System.out.println(weifukuan.getState());
  5.     }
  6. }

2.枚举的方法_Enum

方法名 说明
String toString() 返回枚举常量的名称，它包含在声明中
values() 返回枚举类型的对象数组,可以快速遍历出所有的枚举值
valueOf(String str) 将一个字符串转成枚举类型 
  1. public enum Color {
  2.     RED("红色"),//Color RED = new Color()
  3.     GREEN("绿色"),//Color GREEN = new Color()
  4.     YELLOW("黄色");//Color YELLOW = new Color()
  6.     private String color;
  8.     Color() {
  9.     }
  11.     Color(String color) {
  12.         this.color = color;
  13.     }
  15.     public String getColor() {
  16.         return color;
  17.     }
  18. }
  1. public class Test03_Method {
  2.     public static void main(String[] args) {
  3.         //String toString()返回枚举常量的名称，它包含在声明中
  4.         Color red = Color.RED;
  5.         System.out.println(red.toString());
  7.         System.out.println("=======================");
  8.         //values()返回枚举类型的对象数组,可以快速遍历出所有的枚举值
  9.         Color[] values = Color.values();
  10.         for (Color value : values) {
  11.             System.out.println(value.getColor());
  12.         }
  14.         System.out.println("=====================");
  15.         // valueOf(String str)  将一个字符串转成枚举类型
  16.         Color red1 = Color.valueOf("RED");
  17.         System.out.println(red1);
  18.     }
  19. }
  1. 小结:
  2. 1.枚举主要是做状态使用
  3. 2.枚举类中的常量(枚举),都是当前枚举类的对象
  4. 3.如果想给枚举赋值,需要提供有参构造
  5. 4.使用:类名直接调用
  6. 5.注意: 
  7.   枚举类中的枚举:被public static final修饰
  8.   枚举类中的构造:必须是private的

二. 软件结构

  • C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、红蜘蛛、飞秋等软件。

day20[枚举_网络编程] - 图1

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

day20[枚举_网络编程] - 图2

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

三.服务器概念

day20[枚举_网络编程] - 图3

  1. 1.安装了服务器软件的计算接,才能称之为是一台服务器

网络通信协议:两台计算机在做数据交互时要遵守的规则,协议会对数据的格式,速率等进行规定,只有都遵守了这个协议,才能完成数据交互

两台计算机想完成数据交互,需要遵守网络通信协议

三.通信三要素

  1. [IP地址]:计算机的唯一标识,用于两台计算机之间的连接
  3.       a.概述:指互联网协议地址（Internet Protocol Address），俗称IP
  4.             计算机的唯一标识
  5.       b.作用:可用于计算机和计算机之间的连接
  6.       c.IPV4
  7.         32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
  8.         IPV6
  9.         为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789->号称能给地球上的每一粒沙子分配一个IP地址
  11.       d.查看ip的命令:ipconfig
  12.         测试是否能连接其他计算机的命令:ping ip地址
  14.       e:特殊的网址:代表的是本机地址,到了哪里都不会变,代表自己
  15.         127.0.0.1
  16.         localhost
  19. [协议]
  20.      TCP:面向连接协议
  21.          需要先确认连接,才能进行数据交互
  22.          三次握手:
  23.             - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  24.             - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  25.             - 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
  27.          好处:数据安全,能给数据的传输提供一个安全的传输环境
  28.          坏处:效率低
  30.      UDP:面向无连接协议
  31.          好处:效率高
  32.          坏处:传输的数据不安全,容易丢失数据包
  34. [端口号]
  35.    每一个应用程序的唯一标识
  37.   用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

day20[枚举_网络编程] - 图4

TCP协议中的三次握手和四次挥手

  1. 三次握手:
  2. - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  3. - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  4. - 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
  1. 四次挥手:
  2. - 第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
  3. - 第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
  4. - 第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
  5. - 第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。
  1. 小结:
  2.   1.服务器:安装了服务器软件的计算机
  3.   2.通信三要素:
  4.     IP:每一台计算机的唯一标识,连接计算机的
  5.     协议:TCP(重点)面向连接协议(三次握手,四次挥手)  UDP(面向无连接协议)
  6.     端口号:每一个应用程序的唯一表示
  7.   3.软件架构:
  8.     CS:安装app-> lol  QQ  迅雷等
  9.     BS:可以通过浏览器访问-> 淘宝网站  学生信息网等

四.实现简单客户端和服务端的交互

day20[枚举_网络编程] - 图5

一.编写客户端

  1. 1.创建Socket对象,指明服务端的IP以及端口号
  2. 2.调用Socket中的getOutputStream,往服务端发请求(写数据)
  3. 3.调用Socket中的getInputStream,读取服务端发来的响应结果(读数据)
  4. 4.关闭资源
  1. public class Client {
  2.     public static void main(String[] args)throws Exception {
  3.         //1.创建Socket对象,指明服务端的IP以及端口号
  4.         Socket socket = new Socket("127.0.0.1", 6666);
  5.         //2.调用Socket中的getOutputStream,往服务端发请求(写数据)
  6.         OutputStream os = socket.getOutputStream();
  7.         os.write("你好吗?服务器".getBytes());
  8.         //3.调用Socket中的getInputStream,读取服务端发来的响应结果(读数据)
  9.         InputStream is = socket.getInputStream();
  10.         byte[] bytes = new byte[1024];
  11.         int read = is.read(bytes);
  12.         System.out.println(new String(bytes,0,read));
  13.         //4.关闭资源
  14.         is.close();
  15.         os.close();
  16.         socket.close();
  17.     }
  18. }

二.编写服务端

  1. 1.创建ServerSocket对象,指明端口号
  2. 2.调用ServerSocket中的accept方法,等待连接服务器的客户端对象
  3. 3.调用Socket中的getInputStream,读取客户端发来的请求(读数据)
  4. 4.调用Socket中的getOutputStream,往客户端写响应(写数据)
  5. 5.关闭资源
  1. public class Server {
  2.     public static void main(String[] args)throws Exception {
  3.         //1.创建ServerSocket对象,指明端口号
  4.         ServerSocket ss = new ServerSocket(6666);
  5.         //2.调用ServerSocket中的accept方法,等待连接服务器的客户端对象
  6.         Socket socket = ss.accept();
  7.         //3.调用Socket中的getInputStream,读取客户端发来的请求(读数据)
  8.         InputStream is = socket.getInputStream();
  9.         byte[] bytes = new byte[1024];
  10.         int read = is.read(bytes);
  11.         System.out.println(new String(bytes,0,read));
  12.         //4.调用Socket中的getOutputStream,往客户端写响应(写数据)
  13.         OutputStream os = socket.getOutputStream();
  14.         os.write("我不好,客户端".getBytes());
  15.         //5.关闭资源
  16.         os.close();
  17.         is.close();
  18.         socket.close();
  19.         ss.close();
  20.     }
  21. }

经验值传授:

Exception in thread “main” java.net.BindException: Address already in use: JVM_Bind

解释:

端口号被占用

原因:连续开启了多次服务器

五.文件上传

day20[枚举_网络编程] - 图6

一.文件上传客户端以及服务端实现

  1. //客户端
  2. public class Client {
  3.     public static void main(String[] args)throws Exception {
  4.         //1.创建Socket对象
  5.         Socket socket = new Socket("127.0.0.1", 6666);
  6.         //2.创建FileInputStream将本地上要上传的图片读到内存中
  7.         FileInputStream fis = new FileInputStream("E:\\io\\1.jpg");
  8.         //3.调用Socket中的getOutputStream用于将读取到的图片写到服务端
  9.         OutputStream os = socket.getOutputStream();
  10.         //4.边读编写
  11.         byte[] bytes1 = new byte[1024];
  12.         int len;
  13.         while((len = fis.read(bytes1))!=-1){
  14.             os.write(bytes1,0,len);
  15.         }
  18.         socket.shutdownOutput();
  20.         System.out.println("============以下代码是读取服务端发来的响应==========");
  22.         //5.调用Socket中的getInputStream,读取服务端发来的数据
  23.         InputStream is = socket.getInputStream();
  24.         byte[] bytes2 = new byte[1024];
  25.         int len1 = is.read(bytes2);
  26.         System.out.println(new String(bytes2,0,len1));
  28.         //6.关闭资源
  29.         is.close();
  30.         os.close();
  31.         fis.close();
  32.         socket.close();
  33.     }
  34. }
  1. //服务端
  2. public class Server {
  3.     public static void main(String[] args) throws Exception {
  4.         //1.创建ServerSocket对象
  5.         ServerSocket ss = new ServerSocket(6666);
  6.         //2.调用ServerSocket中的accept方法等待获取连接的客户端对象
  7.         Socket socket = ss.accept();
  8.         //3.调用socket中的getInputStream读取客户端发来的图片数据
  9.         InputStream is = socket.getInputStream();
  10.         //4.创建FileOutputStream,将读到的图片写到服务端指定的位置
  11.         String name = System.currentTimeMillis()+""+new Random().nextInt()+".jpg";
  12.         FileOutputStream fos = new FileOutputStream("E:\\io\\upload\\"+name);
  13.         //5.边读边写
  14.         byte[] bytes1 = new byte[1024];
  15.         int len;
  16.         while((len = is.read(bytes1))!=-1){
  17.             fos.write(bytes1,0,len);
  18.         }
  20.         System.out.println("======以下代码是给客户端写响应结果========");
  22.         //6.调用Socket中的getOutputStream,给客户端写内容
  23.         OutputStream os = socket.getOutputStream();
  24.         os.write("上传成功".getBytes());
  26.         //7.关闭资源
  27.         os.close();
  28.         fos.close();
  29.         is.close();
  30.         socket.close();
  31.     }
  32. }

二.文件上传服务端实现(多线程)

  1. //服务端
  2. public class Server_Thread {
  3.     public static void main(String[] args) throws Exception {
  4.         //1.创建ServerSocket对象
  5.         ServerSocket ss = new ServerSocket(6666);
  6.         while(true){
  7.             //2.调用ServerSocket中的accept方法等待获取连接的客户端对象
  8.             Socket socket = ss.accept();
  9.             new Thread(new Runnable() {
  10.                 @Override
  11.                 public void run() {
  12.                     InputStream is = null;
  13.                     FileOutputStream fos = null;
  14.                     OutputStream os = null;
  15.                     try{
  16.                         //3.调用socket中的getInputStream读取客户端发来的图片数据
  17.                        is = socket.getInputStream();
  18.                         //4.创建FileOutputStream,将读到的图片写到服务端指定的位置
  19.                         String name = System.currentTimeMillis()+""+new Random().nextInt()+".jpg";
  20.                        fos  = new FileOutputStream("E:\\io\\upload\\"+name);
  21.                         //5.边读边写
  22.                         byte[] bytes1 = new byte[1024];
  23.                         int len;
  24.                         while((len = is.read(bytes1))!=-1){
  25.                             fos.write(bytes1,0,len);
  26.                         }
  28.                         System.out.println("======以下代码是给客户端写响应结果========");
  30.                         //6.调用Socket中的getOutputStream,给客户端写内容
  31.                         os = socket.getOutputStream();
  32.                         os.write("上传成功".getBytes());
  34.                     }catch (Exception e){
  35.                         e.printStackTrace();
  36.                     }finally {
  37.                         //7.关闭资源
  38.                         CloseUtils.close(os,fos,is,socket);
  39.                     }
  40.                 }
  41.             }).start();
  42.         }
  43.     }
  44. }

三.文件上传服务器端(连接池版本)

  1. //服务端
  2. public class Server_Thread_Pool {
  3.     public static void main(String[] args) throws Exception {
  4.         //1.创建ServerSocket对象
  5.         ServerSocket ss = new ServerSocket(6666);
  7.         //创建线程池对象
  8.         ExecutorService es = Executors.newFixedThreadPool(50);
  10.         while(true){
  11.             //2.调用ServerSocket中的accept方法等待获取连接的客户端对象
  12.             Socket socket = ss.accept();
  13.             es.submit(new Runnable() {
  14.                 @Override
  15.                 public void run() {
  16.                     InputStream is = null;
  17.                     FileOutputStream fos = null;
  18.                     OutputStream os = null;
  19.                     try{
  20.                         //3.调用socket中的getInputStream读取客户端发来的图片数据
  21.                        is = socket.getInputStream();
  22.                         //4.创建FileOutputStream,将读到的图片写到服务端指定的位置
  23.                         String name = System.currentTimeMillis()+""+new Random().nextInt()+".jpg";
  24.                        fos  = new FileOutputStream("E:\\io\\upload\\"+name);
  25.                         //5.边读边写
  26.                         byte[] bytes1 = new byte[1024];
  27.                         int len;
  28.                         while((len = is.read(bytes1))!=-1){
  29.                             fos.write(bytes1,0,len);
  30.                         }
  32.                         System.out.println("======以下代码是给客户端写响应结果========");
  34.                         //6.调用Socket中的getOutputStream,给客户端写内容
  35.                         os = socket.getOutputStream();
  36.                         os.write("上传成功".getBytes());
  38.                     }catch (Exception e){
  39.                         e.printStackTrace();
  40.                     }finally {
  41.                         //7.关闭资源
  42.                         CloseUtils.close(os,fos,is,socket);
  43.                     }
  44.                 }
  45.             });
  46.         }
  47.     }
  48. }

四.关闭资源工具类

  1. public class CloseUtils {
  2.     public static void close(OutputStream os, FileOutputStream fos, InputStream is, Socket socket){
  3.         if (os!=null){
  4.             try {
  5.                 os.close();
  6.             } catch (IOException e) {
  7.                 e.printStackTrace();
  8.             }
  9.         }
  10.         if (fos!=null){
  11.             try {
  12.                 fos.close();
  13.             } catch (IOException e) {
  14.                 e.printStackTrace();
  15.             }
  16.         }
  18.         if (is!=null){
  19.             try {
  20.                 is.close();
  21.             } catch (IOException e) {
  22.                 e.printStackTrace();
  23.             }
  24.         }
  26.         if (socket!=null){
  27.             try {
  28.                 socket.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }

六.BS架构服务器案例

day20[枚举_网络编程] - 图7

一.案例分析

day20[枚举_网络编程] - 图8

二.BS结构服务器代码实现

  1. /*
  2.    如果想调用BufferedReader中的readLine方法,
  3.    我们就要想办法将InputStream转成BufferedReader
  5.    BufferedReader构造:
  6.      BufferedReader(Reader in)
  7.                     Reader是抽象类,所以需要传递Reader的子类:FileReader  InputStreamReader
  8.      InputStreamReader的构造:
  9.          InputStreamReader(InputStream in)
  11.  */
  12. public class BSServer {
  13.     public static void main(String[] args)throws Exception {
  14.         //1.创建ServerSocket对象
  15.         ServerSocket ss = new ServerSocket(8888);
  16.         while(true){
  17.             //2.调用accept接收连接的客户端对象
  18.             Socket socket = ss.accept();
  19.             //3.调用socket中的getInputStream,读取客户端发来的请求
  20.             InputStream is = socket.getInputStream();
  21.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
  22.             String s = br.readLine();//     GET /day20/web/index.html HTTP/1.1
  23.             String[] s1 = s.split(" ");
  24.             String s2 = s1[1];//   /day20/web/index.html
  25.             String path = s2.substring(1);//   day20/web/index.html
  26.             //4.创建FileInputStream,根据解析出来的路径,找到本地上的html,读到内存中
  27.             FileInputStream fis = new FileInputStream(path);
  28.             //5.调用socket中的getOutputStream.将读到的html写会给浏览器
  29.             OutputStream os = socket.getOutputStream();
  30.             //写响应信息给浏览器
  31.             os.write("HTTP/1.1 200 OK\r\n".getBytes());
  32.             os.write("Content-Type:text/html\r\n".getBytes());
  33.             os.write("\r\n".getBytes());
  35.             //6.边读边写
  36.             byte[] bytes = new byte[1024];
  37.             int len;
  38.             while ((len = fis.read(bytes))!=-1){
  39.                 os.write(bytes,0,len);
  40.             }
  42.             //7.关闭资源
  43.             os.close();
  44.             fis.close();
  45.             br.close();
  46.             is.close();
  47.             socket.close();
  48.         }
  50.     }
  51. }
  1. 案例总结:
  2.  1.创建ServerSocket对象,指定端口号
  3.  2.调用accpet()接收连接服务端的客户端对象
  4.  3.调用getInputStream,读取请求信息
  5.  4.将InputStream转成BufferedReader读取请求信息的第一行(因为第一行是请求路径)
  6.  5.解析:将请求路径中的 模块名/文件夹名/index.html  解析出来
  7.  6.利用解析出来的路径创建FileInputStream,根据路径读取本地上的index.html
  8.  7.调用getOutpuStream,往浏览器上写(响应)index.html
  9.  8.在响应之前,将响应给浏览器的响应信息先写给浏览器
  10.  9.边读,边写

三.BS结构服务器代码实现(多线程版本)

  1. public class BSServer_Thread {
  2.     public static void main(String[] args)throws Exception {
  3.         //1.创建ServerSocket对象
  4.         ServerSocket ss = new ServerSocket(8888);
  5.         while(true){
  6.             //2.调用accept接收连接的客户端对象
  7.             Socket socket = ss.accept();
  9.             new Thread(new Runnable() {
  10.                 @Override
  11.                 public void run() {
  12.                     InputStream is = null;
  13.                     BufferedReader br = null;
  14.                     FileInputStream fis = null;
  15.                     OutputStream os = null;
  16.                     try{
  17.                         //3.调用socket中的getInputStream,读取客户端发来的请求
  18.                         is = socket.getInputStream();
  19.                         br = new BufferedReader(new InputStreamReader(is));
  20.                         String s = br.readLine();//     GET /day20/web/index.html HTTP/1.1
  21.                         String[] s1 = s.split(" ");
  22.                         String s2 = s1[1];//   /day20/web/index.html
  23.                         String path = s2.substring(1);//   day20/web/index.html
  24.                         //4.创建FileInputStream,根据解析出来的路径,找到本地上的html,读到内存中
  25.                         fis = new FileInputStream(path);
  26.                         //5.调用socket中的getOutputStream.将读到的html写会给浏览器
  27.                          os = socket.getOutputStream();
  28.                         //写响应信息给浏览器
  29.                         os.write("HTTP/1.1 200 OK\r\n".getBytes());
  30.                         os.write("Content-Type:text/html\r\n".getBytes());
  31.                         os.write("\r\n".getBytes());
  33.                         //6.边读边写
  34.                         byte[] bytes = new byte[1024];
  35.                         int len;
  36.                         while ((len = fis.read(bytes))!=-1){
  37.                             os.write(bytes,0,len);
  38.                         }
  39.                     }catch (Exception e){
  40.                         e.printStackTrace();
  41.                     }finally {
  42.                         //7.关闭资源
  43.                         //关流
  44.                         if (os != null) {
  45.                             try {
  46.                                 os.close();
  47.                             } catch (IOException e) {
  48.                                 e.printStackTrace();
  49.                             }
  50.                         }
  51.                         if (fis!=null){
  52.                             try {
  53.                                 fis.close();
  54.                             } catch (IOException e) {
  55.                                 e.printStackTrace();
  56.                             }
  57.                         }
  58.                         if (br!=null){
  59.                             try {
  60.                                 br.close();
  61.                             } catch (IOException e) {
  62.                                 e.printStackTrace();
  63.                             }
  64.                         }
  65.                         if (is!=null){
  66.                             try {
  67.                                 is.close();
  68.                             } catch (IOException e) {
  69.                                 e.printStackTrace();
  70.                             }
  71.                         }
  73.                         if (socket!=null){
  74.                             try {
  75.                                 socket.close();
  76.                             } catch (IOException e) {
  77.                                 e.printStackTrace();
  78.                             }
  79.                         }
  80.                     }
  81.                 }
  82.             }).start();
  83.         }
  84.     }
  85. }