【javaweb】自己动手实现简易的Tomcat

最新推荐文章于 2021-12-26 13:51:07 发布
最新推荐文章于 2021-12-26 13:51:07 发布
阅读量802 收藏 6
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iNiBuBian/article/details/89107751
版权

单线程版本：

转载自：https://blog.csdn.net/weixin_39033443/article/details/83901722

分以下几个步骤：
（1）提供Socket服务
（2）把请求和响应封装成request/response
（3）进行请求的转发

代码实现如下：
1、工程截图：

å¨è¿éæå¥å¾çæè¿°

2、封装请求对象：通过输入流，对HTTP协议进行解析，拿到了HTTP请求头的方法和URL：


/**
 * @author wangjie
 * @version 2018/11/9
 * 封装请求对象
 * 通过输入流，对http协议进行解析，拿到http请求头的方法和url
 */
public class MyRequest {
    private String url; // 请求url
    private String method; // 请求方法

    public MyRequest(InputStream inputStream) throws IOException{
        String httpRequest ="";
        byte[] httpRequestBytes =new byte[1024];
        int length =0;
        if((length=inputStream.read(httpRequestBytes)) >0){
            httpRequest=new String(httpRequestBytes,0,length);
        }

        String httpHead = httpRequest.split("\n")[0]; // 切割换行符“\n”
        url=httpHead.split("\\s")[1]; // 切割空格“\\s”
        method=httpHead.split("\\s")[0];
        System.out.println(this);
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getMethod() {
        return method;
    }
    public void setMethod(String method) {
        this.method = method;
    }
}

小结：

String httpHead = httpRequest.split("\n")[0]; // 切割换行符“\n”
String url=httpHead.split("\\s")[1]; // 切割空格“\\s”

3、封装响应对象：基于HTTP协议的格式进行输出写入。

/**
 * @author wangjie
 * @version 2018/11/9
 * 封装响应对象
 * 基于HTTP协议的格式进行输出写入。
 */
public class MyResponse {
    private OutputStream outputStream;

    public MyResponse(OutputStream outputStream){
        this.outputStream = outputStream;
    }

    public void write(String content)throws IOException {
        StringBuffer httpResponse = new StringBuffer();
        httpResponse.append("HTTP/1.1 200 OK\n")
                .append("Content-Type: text/html\n")
                .append("\r\n")
                .append("<html><body>")
                .append(content)
                .append("</body></html>");
        outputStream.write(httpResponse.toString().getBytes());
        outputStream.close();
    }
}

小结：

Response对象的write()方法，底层调用的是OutputStream的write()方法来往客户端进行写出响应

4、servlet请求处理基类：Tomcat是满足Servlet规范的容器，所以Tomcat需要提供API：doGet/doPost/service。

/**
 * @author wangjie
 * @version 2018/11/9
 * Servlet请求处理基类
 */
public abstract class MyServlet {
    public abstract void doGet(MyRequest myRequest,MyResponse myResponse);
    public abstract void doPost(MyRequest myRequest,MyResponse myResponse);
    public void service(MyRequest myRequest,MyResponse myResponse){ // 判断请求方法类型，进行请求转发
        if(myRequest.getMethod().equalsIgnoreCase("POST")){
            doPost(myRequest,myResponse);
        }else if(myRequest.getMethod().equalsIgnoreCase("GET")){
            doGet(myRequest,myResponse);
        }
    }
}

5、Servlet实现类：提供2个实现类，用于测试。

/**
 * @author wangjie
 * @version 2018/11/9
 * servlet实现类
 */
public class FindGirlServlet extends MyServlet{
    @Override
    public void doGet(MyRequest myRequest,MyResponse myResponse){
        try{
            myResponse.write("get gril....");
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    @Override
    public void doPost(MyRequest myRequest,MyResponse myResponse){
        try{
            myResponse.write("post girl...");
        } catch (IOException e){
            e.printStackTrace();
        }
    }
}

/**
 * @author wangjie
 * @version 2018/11/9
 */
public class HelloWorldServlet extends MyServlet {
    @Override
    public void doGet(MyRequest myRequest,MyResponse myResponse){
        try{
            myResponse.write("get world...");
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    @Override
    public void doPost(MyRequest myRequest,MyResponse myResponse){
        try{
            myResponse.write("post world...");
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

6、Servlet配置：对比之前在web开发中，会在web.xml中通过和指定哪个URL交给哪个servlet来处理。

/**
 * @author wangjie
 * @version 2018/11/9
 * servlet配置
 */
public class ServletMapping {
    private String servletName;
    private String url;
    private String clazz;

    public ServletMapping(String servletName, String url, String clazz){
        this.servletName=servletName;
        this.url=url;
        this.clazz=clazz;
    }

    public String getServletName() {
        return servletName;
    }
    public void setServletName(String servletName) {
        this.servletName = servletName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getClazz() {
        return clazz;
    }
    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

/**
 * @author wangjie
 * @version 2018/11/9
 */
public class ServletMappingConfig {
    public static List<ServletMapping> servletMappingList =new ArrayList<>();
    //制定哪个URL交给哪个servlet来处理
    static{
        servletMappingList.add(new ServletMapping("findGirl","/girl","wj.mytomcat.FindGirlServlet"));
        servletMappingList.add(new ServletMapping("helloWorld","/world","wj.mytomcat.HelloWorldServlet"));
    }
}

7、启动类：
tomcat的处理流程：

1）把URL对应处理的Servlet关系形成，

2）解析HTTP协议，

3）封装请求/响应对象，

4）利用反射实例化具体的Servlet进行请求处理。

/**
 * @author wangjie
 * @version 2018/11/9
 * tomcat启动类
 */
public class MyTomcat {
    private int port=8088;
    private Map<String,String> urlServletMap =new HashMap<String,String>();
    public MyTomcat(int port){
        this.port=port;
    }

    public void start(){
//        初始化URL与对应处理的servlet的关系
        initServletMapping();

        ServerSocket serverSocket=null;
        try{
            serverSocket = new ServerSocket(port);
            System.out.println("MyTomcat is start...");

            while(true){
                Socket socket= serverSocket.accept();
                InputStream inputStream=socket.getInputStream();
                OutputStream outputStream=socket.getOutputStream();

                MyRequest myRequest= new MyRequest(inputStream);
                MyResponse myResponse =new MyResponse(outputStream);

//                请求分发
                dispatch(myRequest,myResponse);
                socket.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (null != serverSocket){
                try{
                    serverSocket.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    private void initServletMapping(){
        for(ServletMapping servletMapping:ServletMappingConfig.servletMappingList){
            urlServletMap.put(servletMapping.getUrl(),servletMapping.getClazz());
        }
    }

    public void dispatch(MyRequest myRequest,MyResponse myResponse){
        String clazz =urlServletMap.get(myRequest.getUrl());

        //反射：生成具体的Servlet实例
        try{
            Class<MyServlet> myServletClass =(Class<MyServlet>) Class.forName(clazz);
            MyServlet myServlet= myServletClass.newInstance();

            myServlet.service(myRequest,myResponse); // 调用Servlet的service()进行请求处理
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }catch (InstantiationException e){
            e.printStackTrace();
        }catch (IllegalAccessException e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args){
        new MyTomcat(8088).start();
    }
}

8、测试：
运行项目后，在浏览器输入:localhost:8088/girl
在这里插入图片描述
在浏览器输入：localhost:8088/world
在这里插入图片描述
实践完成。

 

多线程版本：

 一个ClientRequestHandler负责接收一个clientSocket，从而处理一次客户端请求

package cn.huangyan.web.tomcat;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Map;

/*
 * 一个ClientRequestHandler负责接收一个clientSocket，从而处理一次客户端请求
 * */
public class ClientRequestHandler implements Runnable {

	Socket clientSocket = null;
	Map<String,String> urlServletMap = null;
	
	public ClientRequestHandler(Socket clientSocket,Map<String,String> urlServletMap) {
		this.clientSocket = clientSocket;
		this.urlServletMap = urlServletMap;
	}
	
	@Override
	public void run() {
		
		OutputStream os = null;
		InputStream is = null;
		System.out.println("当前线程是："+Thread.currentThread().getName());
		try {
			is = clientSocket.getInputStream();
			os = clientSocket.getOutputStream();
			MyRequest request = new MyRequest(is);
			MyResponse response = new MyResponse(os);
			
			doDispatch(request,response);
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(clientSocket != null) {
				try {
					clientSocket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}

	private void doDispatch(MyRequest request, MyResponse response) {
		String url = request.getUrl();
		String className = urlServletMap.get(url);
		try {
			Class clazz = Class.forName(className);
			MyServlet servlet = (MyServlet) clazz.newInstance();
			servlet.service(request, response);

		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		}

	}
}

MyTomcat类

package cn.huangyan.web.tomcat;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

public class MyTomcat {

	private int port = 8080;
	private Map<String,String> urlServletMap  = new HashMap<>();

	public MyTomcat(int port) {
		this.port = port;
	}

	public void start() {
		initServletMapping();

		ServerSocket serverSocket = null;
		try {
			serverSocket = new ServerSocket(port);
			while(true) {
				Socket clientSocket = serverSocket.accept();
				
				// 每个客户端请求分配一个线程进行处理
				new Thread(new ClientRequestHandler(clientSocket, urlServletMap)).start();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void initServletMapping() {
		for(ServletMapping servletMapping : ServletMappingConfig.servletMappingList) {
			urlServletMap.put(servletMapping.getUrl(), servletMapping.getClazzName());
		}
	}

	public static void main(String[] args) {
		System.out.println("进来了");
		new MyTomcat(8080).start();
	}
}

 

每天的每一天
关注
自己实现Tomcat-完善版
06-24
该包含Mytomcat源码和Mytomcat使用安装包。MyTomcat.zip是使用文件，就像我们下的tomcat一样 解压后，配置环境变量MT_HOME 然后启动服务器即可 里面有测试文件.....
实现一个简易的Tomcat
weixin_44794676的博客
06-30 201
过渡课：实现一个简易的Tomcat 1. 过渡课的总目标 前端和数据库的学习时间为期有一个月左右，很多同学Java内容已经忘光了！ 后端Java EE内容比较难，所以我们一下子进来可能不太适应，需要过渡一下。 希望能够通过过渡课对于客户端和服务端的网络通信有一个比较清晰的了解。 BS和CS架构 2. 了解HTTP协议 2.1 协议的概念 一方或者多方约定好的一个规范。 TCP（传输控制协议）...
【javaweb】自己动手实现简易的Tomcat2
iNiBuBian的博客
04-10 274
一个服务器server中可以存放jd，oa这样的多个web应用； Web应用是通过sun公司制定的servlet接口与Tomcat，JBoss等多个服务器解耦合的 所以，同一个web应用，就可以运行在多种不同的服务器上；（Tomcat，JBoss等服务器就是通过sun制定的Servlet接口来找到要执行的servlet类，从而启动web应用） Java程序和数据库也是 JDBC接...
自制简易Tomcat服务器
haohulala的博客
12-26 1079
在学习javaweb的时候我感觉自己是很懵逼的，因为好像就是写servlet然后配置web.xml，就可以让服务器提供服务了，对于这整个过程都不是很了解。为了弄懂整个的过程，我就找了黑马的自制简易Tomcat的视频，现将代码记录与这篇文章中。相信你看完整个过程，会对javaweb有更深的理解 模拟浏览器给服务器发送请求 // 模拟浏览器向服务器发送HTTP请求 public class TestClient { private static Socket socket = null;
javaWeb SSH框架简易登录
08-25
JavaWeb SSH框架简易登录是一个适合初学者学习的项目，它主要涵盖了Struts2、Spring和Hibernate这三大流行JavaWeb开发框架的集成应用。这个项目旨在帮助开发者理解如何将这三个框架协同工作，实现一个简单的用户登录...
Javaweb个人博客管理系统 源码
11-25
【JavaWeb个人博客管理系统源码解析】 在信息技术领域，JavaWeb技术被广泛应用于构建各种复杂的互联网应用程序，包括...此外，这样的项目也适合作为初学者学习JavaWeb的实战练习，有助于提升动手能力和问题解决能力。
尚硅谷全新JavaWeb教程，企业主流javaweb技术栈 中代码
最新发布
04-07
通过这个项目，你可以亲自动手实践，从零开始构建一个完整的JavaWeb应用，涵盖从需求分析到编码、测试和部署的全过程。 五、其他相关技术 除了Tomcat和Servlet，企业级的JavaWeb开发还涉及到JSP（JavaServer Pages...
javaweb笔记+代码(狂神说java)
08-27
11. **Tomcat服务器**: Tomcat是Apache软件基金会的开源项目，是一个流行的Java Web应用服务器，支持Servlet和JSP规范。 12. **Eclipse或IntelliJ IDEA**: 这些是常用的Java集成开发环境（IDE），用于编写、测试和...
javaweb项目实例
09-14
1. **环境搭建**：这包括安装Java Development Kit (JDK)，设置环境变量，以及安装和配置Web服务器，如Apache Tomcat或Jetty。此外，还需要集成开发环境（IDE），如Eclipse、IntelliJ IDEA等。 2. **项目创建**：在...
自己实现Tomcat
06-23
此篇博客Mytomcat实现的功能只能访问静态资源(图片处理点问题)，我们把项目部署到Mytomcat的webapps目录下，开启MyTomcat服务后，就可以进行访问了！博客：https://blog.csdn.net/m0_37499059/article/details/80779823
简单的Tomcat源码实现
04-06
tomcat的简易源码实现，参考详细内容请搜索csdn用户yang134679
实现一个简单的Tomcat
WangJun的专栏
11-06 1327
实现一个简单的Tomcat 1. Tomcat作用 我们的web应用会运行在Tomcat中，那么显然请求必定是先到达Tomcat的，Tomcat对于请求实际上会进行如下的处理： 提供Socket服务：Tomcat的启动，必然是Socket服务，支持http协议。 进行请求的分发：一个Tomcat可以为多个web应用提供服务，那么就需要把url下发到不同的web应用。 需要将请求和响应封装成req...
自己动手实现Tomcat
weixin_45739339的博客
05-11 150
tomcat的简易实现
qq_45902743的博客
04-12 153
Tomcat介绍 刚接触了Tomcat的底层原理，实现了一个简易的Tomcat，下面是实现的代码 代码文件 HttpServer public class HttpServer extends Thread{ //服务器监听socket private ServerSocket serverSocket; public HttpServer(int port) throws IOException { this.serverSocket = new ServerSocket(port);
自制简易tomcat
勤劳的小蜜蜂
07-31 429
package syson; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.net.ServerSocket; impo...
简易版Tomcat的实现_单应用
BillieFan的博客
05-18 329
学习目标： 对网络部分知识的一个大的总结 —— 原理层面 对Tomcat的基本原理有所了解，打破神秘感 —— 代码层面 更好的进行web开发 —— 实践 Tomcat实现目标： 不考虑效率，不过多的考虑错误处理 HTTP 1.0子集 1）支持GET方法，有限度的支持POST方法 1）Head支持粒度较差 尽可能围绕Tomcat+Servlet的标准走，但不遵守标准 Tomcat + Web 应用并不是分离的 单一的的Web应用 没有配置 web.xml 多客户端的，客户端发送请求到我们写好的Tomc
(深度好文) 自己动手实现Tomcat和SSM框架系列汇总
梦蓝樱飞(一点一滴, 记录个人成长之路)
04-13 883
发现非常不错的文章, 认真看完! 对框架的理解程度, 肯定会提升! (大神请忽略, 本人是一名学生!) 手写一个简化版Tomcat: https://my.oschina.net/liughDevelop/blog/1790893 自己手写一个Spring容器(简化): 主要实现Ioc和AOP功能 https://my.oschina.net/liughDevelop/blog/14...
DIYTomcat
weixin_39361364的博客
08-27 440
项目结构 conf：放置tomcat配置文件 jre8：java运行环境，使能跨平台运行 lib：第三方jar包，以及diytomcat.jar（diytomcat项目中自己写的类打成的jar包） webapps：放置web应用程序 work：放置JSP生成的Servlet的class文件 bootstrap.jar：仅包含cn/how2j/diytomcat/Bootstrap.class cn/how2j/diytomcat/classloader/CommonClassLoader.
JavaWeb课程设计：客户信息管理系统实现
该设计任务旨在检验学生对JavaWeb和数据库知识的理解与应用能力，以及理论与实践相结合的动手能力。 项目的主要要求包括以下几个方面： 1. 明确设计任务：系统需能够管理客户信息，这可能包括客户的基本资料、交易...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值