资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

day02-实现01

实现01

1.实现任务阶段1

编写mytomcat，该服务器能给浏览器返回“你好，我是服务器！”的简单信息。

创新互联公司凭借专业的设计团队扎实的技术支持、优质高效的服务意识和丰厚的资源优势，提供专业的网站策划、网站设计、成都网站制作、网站优化、软件开发、网站改版等服务，在成都十多年的网站建设设计经验，为成都上千中小型企业策划设计了网站。

根据之前的tomcat框架整体分析，我们将浏览器发送请求，tomcat服务器处理请求，返回资源的整个过程分为三个部分。现在来分析并初步实现第一部分的功能。

1.1基于socket开发服务端流程

1.2需求分析/图解

工作：先打通自定义web服务器和浏览器之间的通道。

如浏览器请求http://localhost:8080/Xxx，服务器可以接收请求并返回简单数据。

注意：这里的交互是都建立在http协议之上的。服务器获取到的数据是http格式的，返回的数据也要封装成http格式，浏览器才能正常解析。

http格式详见javaweb-day14-HTTP协议

1.3代码实现

MyTomcatV1：

package com.li.MyTomcat;

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

/**
 * @author 李
 * @version 1.0
 * 这是第一个版本的tomcat，可以完成接收浏览器请求，并返回信息功能
 */
public class MyTomcatV1 {
    public static void main(String[] args) throws IOException {

        //1.创建ServerSocket,在8080端口监听
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("==========mytomcat在8080端口监听=========");
        while (!serverSocket.isClosed()) {
            //等待浏览器或客户端的连接
            //如果有连接来，就创建socket
            //这个socket就是浏览器和服务器之间的连接（通道）
            Socket socket = serverSocket.accept();
            //先接收浏览器发送的数据
            InputStream inputStream = socket.getInputStream();//字节流
            //为了方便，将其转成字符流(InputStreamReader==>转换流，将一个字节流转换成字符流)
            //BufferedReader==>字符处理流
            BufferedReader bufferedReader =
                    new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String mes = null;
            System.out.println("========接收到浏览器发送的数据=======");
            //循环地读取
            while ((mes = bufferedReader.readLine()) != null) {//按行读取数据，如果已到达流末尾，则返回 null
                //判断mes的长度是否为0
                if (mes.length() == 0) {
                    break;//退出while
                }
                System.out.println(mes);
            }

            //我们的tomcat回送数据-按照http格式

            //关闭资源
            inputStream.close();
            socket.close();

        }
    }
}

运行代码，在浏览器中发送请求http://localhost:8080/cal.html，后端输出如下：

可以看到，程序成功接收到了浏览器的请求（http格式）

下面以http格式响应浏览器请求：

package com.li.MyTomcat;

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

/**
 * @author 李
 * @version 1.0
 * 这是第一个版本的tomcat，可以完成接收浏览器请求，并返回信息功能
 */
public class MyTomcatV1 {
    public static void main(String[] args) throws IOException {

            //1.创建ServerSocket,在8080端口监听
            /**
            * ..........
            */

            //mytomcat服务器回送数据-按照http格式
            OutputStream outputStream = socket.getOutputStream();
            //模仿响应头
            //\r\n表示回车换行：因为响应头最后一行和响应体中间要隔一个空行，
            // 所以最后一行要写两个\r\n（响应头换行是空行，空行再换行才是响应体）
            //即 http响应体前面需要有两个换行\r\n\r\n
            String respHeader = "HTTP/1.1 200 OK\r\n" +
                    "Content-Type: text/html;charset=utf-8\r\n\r\n";
            String resp = respHeader + "你好，我是服务器！";

            System.out.println("=====MyTomcat给浏览器回送的数据=====");
            System.out.println(resp);
            //注意：这里返回数据要以字节流方式返回
            outputStream.write(resp.getBytes());//将resp字符串以byte[]方式返回

            //关闭资源
            outputStream.flush();
            outputStream.close();
            inputStream.close();
            socket.close();
        }
    }
}

1.4测试

运行代码，在浏览器中发送请求http://localhost:8080/，后台输出如下：

浏览器输出如下：

2.实现任务阶段2-使用BIO线程模型，支持多线程

2.1BIO线程模型介绍

这里为了简单，使用方式一来完成操作，每次请求都会创建一个线程。

2.2需求分析/图解

  1. 需求分析如图所示，浏览器请求http://localhost:8080/，服务器返回“你好，我是服务器”。
  2. 后台mytomcat使用BIO线程模型，支持多线程，对数据的返回和处理移至线程里处理。

阶段1存在一个问题：当一个客户端被服务端在等待读取数据的时候，服务端会卡在那里，使得别的客户端无法与服务端连接以及收发数据。

解决方案是让等待接收数据的那块让子线程去做，主线程只需要一直监听是否有客户端连接即可，这样每个客户端就相互不影响了。

2.3代码实现

RequestHandler：

package com.li.MyTomcat.hander;

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

/**
 * @author 李
 * @version 1.0
 * RequestHandler是一个线程对象
 * 用来处理一个http请求
 */
public class RequestHandler implements Runnable {
    //定义一个Socket
    private Socket socket = null;

    //在创建RequestHandler对象的时候，将主线程的socket传给线程对象来使用
    public RequestHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        //对客户端进行交互

        try {
            System.out.println("当前线程="+Thread.currentThread().getName());
            
            InputStream inputStream = socket.getInputStream();
            //将字节流转成字符流--方便按行读取浏览器请求
            BufferedReader bufferedReader =
                    new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            System.out.println("=====MyTomcat接收浏览器数据=====");
            String mes = null;
            while ((mes = bufferedReader.readLine()) != null) {
                //如果读取到的长度为零，即空串""
                if (mes.length() == 0) {
                    break;//退出循环
                }
                System.out.println(mes);
            }

            //将数据返回给浏览器/客户端（注意要将数据封装成http响应的格式，浏览器才能解析）
            //构建http响应头（注意换行-响应头和响应体之间有一个空行，需要两个换行）
            String respHeader = "HTTP/1.1 200 OK\r\n" +
                    "Content-Type: text/html;charset=utf-8\r\n\r\n";
            String resp = respHeader + "
Hello，我是服务器！
";
            System.out.println("=====MyTomcatV2给浏览器回送的数据=====");
            System.out.println(resp);
            //获取输出流
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write(resp.getBytes());//将字符串转成字节数组

            //关闭流
            outputStream.flush();
            outputStream.close();
            inputStream.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //一定要确保socket关闭
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MyTomcatV2：

package com.li.MyTomcat;

import com.li.MyTomcat.hander.RequestHandler;

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

public class MyTomcatV2 {
    public static void main(String[] args) throws IOException {
        //监听
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("==========MyTomcatV2在8080端口监听=========");
        //只要serverSocket没有关闭，就会一直等待客户端来连接
        while (!serverSocket.isClosed()) {
            //每接收一个浏览器连接，就会得到一个socket对象（这个socket就是服务器和浏览器的数据通道）
            Socket socket = serverSocket.accept();
            //创建一个线程，将该socket传给该线程，启动线程
            new Thread(new RequestHandler(socket)).start();
        }
    }
}

2.4测试

运行代码，在浏览器输入http://localhost:8080/，输出如下：

后台输出：

3.实现任务阶段3-处理Servlet

  • Servlet声明周期

3.1需求分析/图解

问题分析：第二阶段只是简单地返回结果，没有和Servlet，web.xml关联起来

下面来完成第三阶段实现：

  • 自定义Servlet规范

要完成Servlet的调用就要先制定好Servlet规范，我们模仿Servlet的规范来制订一套自己的Servlet。

如下，模仿实际的Servlet来编写MyServlet及其抽象类MyHttpServlet，实现类MyCalServlet

  • 模拟实现request和response

另外，在真实的tomcat服务器中，接收http请求后会将其封装成HttpServletRequest对象，返回数据则是通过HttpServletResponse对象。

因此，除了自定义Servlet规范外，还要定义用于与http协议交互的两个对象

这里为了简化，就不使用实现接口的形式一层层封装了，直接用两个类来实现。

  • 在实现上面两个工作之前，先来看一个需求

我们现在做一个简单的需求：

浏览器请求http://localhost:8080/calServlet，提交数据，完成计算任务，如果该Servlet不存在，就返回404。大致的界面如下：

由于真正的HttpServletRequest和HttpServletResponse方法以及Servlet方法很多，这里为了简化，上述模拟的Servlet和自定义的request，response等只实现满足此需求的部分方法。

3.2模拟实现request和response

3.2.1MyRequest

package com.li.MyTomcat.http;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;

/**
 * @author 李
 * @version 1.0
 * 1.MyRequest的作用是封装http请求的数据
 * 2.比如 method,uri,还有参数列表等
 * 3.MyRequest 的作用相当于原生的Servlet中的HttpServletRequest
 * 4.这里先考虑get请求
 */
public class MyRequest {

    private String method;
    private String uri;
    //存放参数列表  参数名-参数值=>HashMap
    private HashMap parametersMapping = new HashMap<>();
    private InputStream inputStream = null;

    //构造器==>对http请求进行封装
    //在构造 MyRequest对象的时候，将关联的socket的InputStream传进来
    // 这样就可以拿到该http请求的数据
    public MyRequest(InputStream inputStream) {
        this.inputStream = inputStream;
        packageHttp();
    }

    /**
     * 将http请求的相关参数进行封装，然后提供相关的方法，进行获取
     */
    public void packageHttp() {
        System.out.println("MyRequest packageHttp()被调用...");
        try {
            //将字节流转成字符流
            BufferedReader bufferedReader =
                    new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            /**
             * GET /myCalServlet?num1=11&num2=12 HTTP/1.1
             * Host: localhost:8080
             * User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:106.0) Gecko/20100101 Firefox/106.0
             * ......
             */
            //1.先读取第一行（请求行）
            String requestLine = bufferedReader.readLine();
            //第0组：GET  第1组：/myCalServlet?num1=11&num2=12 第2组：HTTP/1.1
            String[] requestLineArr = requestLine.split(" ");
            //2.得到method
            method = requestLineArr[0];
            //3.解析得到uri=/myCalServlet
            //先看看uri有没有参数列表
            int index = requestLineArr[1].indexOf("?");//找到?号的索引
            if (index == -1) {//没有问号，说明uri没有参数列表
                uri = requestLineArr[1];
            } else {
                //截取到?号的前一位,即为uri
                uri = requestLineArr[1].substring(0, index);
                //获取参数列表
                String parameters = requestLineArr[1].substring(index + 1);//parameters => num1=11&num2=12
                String[] parametersPair = parameters.split("&");//parametersPair=["num1=11","num2=12",...]
                //防止浏览器的提交的地址为 /myCalServlet?
                if (null != parametersPair && !"".equals(parametersPair)) {
                    //再分割
                    for (String parameterPair : parametersPair) {
                        //parameterVal=["num1","10"]
                        String[] parameterVal = parameterPair.split("=");
                        if (parameterVal.length == 2) {
                            //放入到parametersMapping中
                            parametersMapping.put(parameterVal[0], parameterVal[1]);
                        }
                    }
                }
            }
            //这里不能关闭流inputStream，因为inputStream和socket关联，
            // 如果关闭了inputStream则socket也会一起关闭
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //request有一个特别重要的方法-getParameter()
    public String getParameter(String name) {
        if (parametersMapping.containsKey(name)) {
            return parametersMapping.get(name);
        } else {
            return "";
        }
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    @Override
    public String toString() {
        return "MyRequest{" +
                "method='" + method + '\'' +
                ", uri='" + uri + '\'' +
                ", parametersMapping=\n" + parametersMapping +
                '}';
    }
}

3.2.2MyResponse

package com.li.MyTomcat.http;

import java.io.OutputStream;

/**
 * @author 李
 * @version 1.0
 * 1.MyResponse可以封装OutputStream（和socket关联）
 * 2.即可以通过 MyResponse对象返回http响应给浏览器或客户端
 * 3.MyResponse的作用等价于原生的Servlet的HttpServletResponse
 */
public class MyResponse {
    private OutputStream outputStream = null;

    //写一个http的响应头
    public static final String respHeader = "HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/html;charset=utf-8\r\n\r\n";

    //在构造 MyResponse 对象的时候，将关联的socket的OutputStream传进来
    public MyResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    //当我们需要给浏览器返回数据时，可以通过MyResponse的属性获得输出流
    public OutputStream getOutputStream() {
        return outputStream;
    }
}

3.2.3修改RequestHandler

package com.li.MyTomcat.hander;

import com.li.MyTomcat.http.MyRequest;
import com.li.MyTomcat.http.MyResponse;

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

/**
 * @author 李
 * @version 1.0
 * RequestHandler是一个线程对象
 * 用来处理一个http请求
 */
public class RequestHandler implements Runnable {
    //定义一个Socket
    private Socket socket = null;

    //在创建RequestHandler对象的时候，将主线程的socket传给线程对象来使用
    public RequestHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        //对客户端进行交互

        try {
            System.out.println("当前线程=" + Thread.currentThread().getName());

            InputStream inputStream = socket.getInputStream();

            MyRequest myRequest = new MyRequest(inputStream);
            String num1 = myRequest.getParameter("num1");
            String num2 = myRequest.getParameter("num2");
            String name = myRequest.getParameter("name");
            String email = myRequest.getParameter("email");
            System.out.println("请求的参数num1= " + num1);
            System.out.println("请求的参数num2= " + num2);
            System.out.println("请求的参数name= " + name);
            System.out.println("请求的参数email= " + email);
            System.out.println(myRequest);

            //这里我们可以通过myResponse对象返回数据给客户端
            MyResponse myResponse = new MyResponse(socket.getOutputStream());
            String resp = MyResponse.respHeader + "
Hello,我是myResponse返回的信息
";
            //这里的应用场景是:为了将来在Servlet中使用response对象，可以获取到输出流
            OutputStream outputStream = myResponse.getOutputStream();
            outputStream.write(resp.getBytes());
            outputStream.flush();
            outputStream.close();

            inputStream.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //一定要确保socket关闭
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MyTomcatV2类保持不变。

3.2.4测试

运行MyTomcatV2，在浏览器中输入如下请求：

http://localhost:8080/myCalServlet?num1=100&num2=200&name=jack&email=jack@qq.com

浏览器输出：

后台输出：


本文名称：day02-实现01
文章分享：http://cdkjz.cn/article/dsdihgi.html
返回首页 了解更多建站资讯

相关资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求
友情链接 交换友情链接
成都火锅桌椅成都网站推广公司专业网站建设高端网站建设成都名片印刷和县翔豪网站重庆网站制作信衡房屋鉴定移动网站建设成都app开发

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图