手写tomcat(二) 访问servlet

最新推荐文章于 2023-05-02 18:36:59 发布
最新推荐文章于 2023-05-02 18:36:59 发布
阅读量158 收藏 1
点赞数
分类专栏： 笔记
原文链接：https://blog.csdn.net/shenshaoming/article/details/100978449
版权

1、HTTPServer

package core;

import annotations.Servlet;
import baseservlet.AbstractServlet;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Set;


public class HTTPServer {
    /**
     * 监听端口
     */
    public static int port = 8080;

    /**
     * Key值为Servlet的别名(uri),value为该Servlet对象
     * default权限
     */
    static HashMap<String, AbstractServlet> map;

    static {
        //包名,可以通过application.properties设置
        getServlets("servlet");
    }

    static ServerSocket serverSocket = null;


public void acceptWait() {
        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //工作队列
        ArrayBlockingQueue<Runnable> workQueue  = new ArrayBlockingQueue<>(50);
        //线程池的基本大小，即在没有任务需要执行的时候线程池的大小
        int corePoolSize = 10;
        //线程池中允许的最大线程数
        int maximumPoolSize = 50;
        //空闲线程存活时间
        long keepAliveTime = 100L;
        //时间单位
        TimeUnit unit = TimeUnit.SECONDS;
        //拒绝策略
        RejectedExecutionHandler rejectionStrategy = new ThreadPoolExecutor.DiscardOldestPolicy();

        ThreadPoolExecutor tpe = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,keepAliveTime,unit,workQueue, Executors.defaultThreadFactory(),rejectionStrategy);

        while (!serverSocket.isClosed()) {
            try {
                //单线程,阻塞式监听(bio)
                Socket socket = serverSocket.accept();
                RequestHandler handler = new RequestHandler(socket);
                tpe.execute(handler);
                handler.start();
            } catch (IOException e) {
                e.printStackTrace();
                continue;
            }
        }
    }


    private static void getServlets(String packageName) {

        //class类的集合
        Set<Class<?>> classes = new LinkedHashSet<>();

        try {
            String packageDirName = packageName.replace(".", "/");
            Enumeration<URL> resources = Thread.currentThread().getContextClassLoader().getResources(packageDirName);

            while (resources.hasMoreElements()) {
                URL url = resources.nextElement();
                String protocol = url.getProtocol();
                if ("file".equals(protocol)) {
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    findAndAddClassesInPackageByFile(packageName, filePath,true,classes);
                }else if("jar".equals(protocol)){
                    //扫描JAR包
                }
            }
            //遍历class集合
            if (map == null){
                map = new HashMap<>(classes.size());
            }
            for (Class<?> aClass : classes) {
                //如果该class有Servlet注解
                if (aClass.isAnnotationPresent(Servlet.class)){
                    try {
                        //添加至map集合中
                        map.put(aClass.getAnnotation(Servlet.class).value(), (AbstractServlet) aClass.newInstance());
                    } catch (InstantiationException | IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void findAndAddClassesInPackageByFile(String packageName,
                                                        String packagePath, final boolean recursive, Set<Class<?>> classes) {
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在 就获取包下的所有文件 包括目录
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
            @Override
            public boolean accept(File file) {
                return (recursive && file.isDirectory())
                        || (file.getName().endsWith(".class"));
            }
        });
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录 则继续扫描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "."
                                + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    // classes.add(Class.forName(packageName + '.' +
                    // className));
                    // 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
                    classes.add(Thread.currentThread().getContextClassLoader()
                            .loadClass(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }
}

2、Request

package core;

import java.io.IOException;
import java.io.InputStream;


public class Request {

    private InputStream is;

    private String url;

    private String method;

    public Request(){

    }

    public Request(InputStream is){
        this.is = is;
        parse();
    }

    public String getMethod() {
        return method;
    }

    public String getUrl(){
        return url;
    }

    /**
     * 解析url
     */
    public void parse(){
        StringBuilder request = new StringBuilder(Response.BUFFER_SIZE);

        byte[] buffer = new byte[Response.BUFFER_SIZE];

        int i = 0;
        try{
            i = is.read(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }

        for (int j = 0; j < i; j++) {
            request.append((char)buffer[j]);
        }
        System.out.println(request.toString());
        parseUrl(request.toString());
    }

    /**
     *
     * @param request
     * @return
     */
    private void parseUrl(String request) {
        int index1,index2;
        //查看socket获取的请求头是否有值
        index1 = request.indexOf(' ');
        if (index1 != -1){
            this.method = request.substring(0, index1);
            index2 = request.indexOf(' ', index1 + 1);
            if (index2 > index1){
                this.url = request.substring(index1 + 1,index2);
            }
        }
    }

}

3、Response

package core;

import java.io.*;


public class Response {

    public static final Integer BUFFER_SIZE = 2048;

    private static final String WEB_ROOT = "D:";

    private static final String RESPONSE_HEADER = "HTTP/1.1 200 Read File Success\r\n" +
            "Content-Type: text/html;charset=UTF-9\r\n" + "\r\n";

    private Request request;

    private OutputStream outputStream;

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

    public void setRequest(Request request) {
        this.request = request;
    }

    public void sendStaticResource() throws IOException {
        byte[] buffer = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        File file = new File(WEB_ROOT, request.getUrl());
        String returnMsg = null;
        try {
            if (file.exists() && !file.isDirectory()) {
                fis = new FileInputStream(file);
                StringBuilder sb = new StringBuilder();
                int length;
                while ((length = fis.read(buffer, 0, buffer.length)) != -1) {
                    sb.append(new String(buffer, 0, length, "gbk"));
                }
                returnMsg = "HTTP/1.1 200 OK\r\n" +
                        "Content-Type: text/html \r\n" +
                        "Content-Length: " + sb.length() + "\r\n" +
                        "\r\n" +
                        sb.toString();
            } else {
                String errorMsg = "<h1>" + file.getName() + " file or directory not exists</h1>";
                returnMsg = "HTTP/1.1 404 File Not Fount\r\n" +
                        "Content-Type: text/html \r\n" +
                        "Content-Length: " + errorMsg.length() + "\r\n" +
                        "\r\n" +
                        errorMsg;
            }
            outputStream.write(returnMsg.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                fis.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        }
    }

    public void sendResponseContent(StringBuilder message){
        try {
            outputStream.write(new StringBuilder(RESPONSE_HEADER).append(message).toString().getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

4、Requesthandler，收到请求就会开启一个线程去处理

package core;

import baseservlet.AbstractServlet;
import com.sun.net.httpserver.HttpServer;

import java.net.Socket;


public class RequestHandler extends Thread{

    private Socket socket;

    public RequestHandler(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {

        try {
            //接收请求参数
            Request request = new Request(socket.getInputStream());
            AbstractServlet abstractServlet = HTTPServer.map.get(request.getUrl());

            //创建用于返回浏览器的对象
            Response response = new Response(socket.getOutputStream());
            response.setRequest(request);

            if (abstractServlet != null){
                abstractServlet.service(request,response);
            }else{
                //找不到对应的Servlet则直接访问文件
                response.sendStaticResource();
            }
            //如果http短连接则关闭socket
            //socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

5、GenericServlet，定义servlet里的方法

package baseservlet;

import core.Request;
import core.Response;


public interface GenericServlet {

    public void init();

    public void destroy();

    public void service(Request request , Response response);
}

6、AbstractServlet

package baseservlet;

import core.Request;
import core.Response;


public abstract class AbstractServlet implements GenericServlet{

    private static final String GET_METHOD = "GET";

    private static final String POST_METHOD = "POST";


    @Override
    public void service(Request request, Response response) {
        if(GET_METHOD.equalsIgnoreCase(request.getMethod())){
            doGet(request,response);
        }else if (POST_METHOD.equalsIgnoreCase(request.getMethod())){
            doPost(request,response);
        }
    }

    public abstract void doGet(Request request, Response response);

    public abstract void doPost(Request request, Response response);

    @Override
    public void init() {

    }

    @Override
    public void destroy() {

    }

}

7、测试用的servlet

package servlet;

import annotations.Servlet;
import baseservlet.AbstractServlet;
import core.Request;
import core.Response;

//标注路径
@Servlet("/user")
public class UserServlet extends AbstractServlet {

    @Override
    public void doGet(Request request, Response response) {
        doPost(request,response);
    }

    @Override
    public void doPost(Request request, Response response) {
        //执行业务代码
        response.sendResponseContent(new StringBuilder("<h1>Your are requesting the UserServlet</h1>"));
    }

}

8、Main 主启动类

import core.HTTPServer;


public class Main {
    //主启动类
    public static void main(String[] args) {
        HTTPServer httpServer = new HTTPServer();
        httpServer.acceptWait();
    }
}

在上一篇的基础上，实现了访问servlet

想的太多做的太少
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
关于Tomcat启动Servlet工程与映射的访问【JavaWeb】
一键难忘的博客
08-14 553
上文的【Maven父子项目工程中的Servlet优化与准备】一文中我们已经建立好了需要的工程，本文，我们尝试搭建第一个Servlet项目。
Tomcat如何与Servlet对象进行交互
jing12062011的博客
11-13 791
Tomcat 是Web应用服务器,是一个Servlet/JSP容器. Tomcat 作为Servlet容器,负责处理客户请求,把请求传送给Servlet,并将Servlet的响应传送回给客户.而Servlet是一种运行在支持Java语言的服务器上的组件. Servlet最常见的用途是扩展Java Web服务器功能,提供非常安全的,可移植的,易于使用的CGI替代品.下面我们描述一下Tomcat与Se
【JavaEE+servlet】 Servlet 运行原理
xqs196301的博客
06-13 283
【JavaEE+servlet】 Servlet 运行原理
Tomca和Servlet简单配置和使用
weixin_46266624的博客
10-22 795
Tomcat和Servlet简单配置和使用
IDEA 创建 Servlet 项目并使用 tomcat 访问
weixin_39149333的博客
05-11 1280
目录 一、IDEA 创建项目 二、Maven 环境优化 三、编写 Servlet 接口 【动态网页】 四、编写静态web网页（可选，用于测试） 五、配置 Tomcat 六、启动 Tomcat，测试访问文件 一、IDEA 创建项目 （一）创建 maven javaweb 项目 1. 在 IDEA 中新建一个 project，选择需要的模板： 2. 填写Name，Group ID（可填可不填）： 3. 选择 Maven 的版本：自定义或使用 IDEA 自带的，我这里使用自定义的
使用Tomcat运行Servlet程序
m0_46638350的博客
01-25 2002
Tomcat安装教程 参考：Tomcat安装配置教程 Tomcat启动 1. 启动Tomcat服务器 如果在浏览器输入localhost:8080，出现Tomcat首页即启动成功。 Tomcat使用 Java提供了Servlet API，我们在Servlet API中实现自己的Servlet来处理Http请求 文件总体结构 1. pom.xml中导入Servlet API 注意到这个pom.xml与前面我们讲到的普通Java程序有个区别，打包类型不是jar，而是war，表示Java Web App
手写 tomcat nio
01-22
在深入探讨手写Tomcat NIO之前，我们首先需要理解NIO（Non-blocking I/O）的概念。NIO是Java提供的一个用于替代传统I/O模型（即BIO，Blocking I/O）的库。在BIO中，每个连接都需要一个单独的线程进行处理，当并发...
手写tomcat
06-03
在手写Tomcat时，我们需要实现Servlet容器的基本功能，包括Servlet的加载、初始化、请求分发等。 2. **HTTP协议**：理解HTTP协议是构建Tomcat的基础，需要了解HTTP请求头、请求体、响应状态码、响应头等内容，并能...
手写Tomcat全家桶
04-08
【标题】"手写Tomcat全家桶"是一个深入理解并实践Apache Tomcat服务器的项目，旨在帮助开发者通过自己动手编写代码来深入理解Tomcat的工作原理和内部机制。这个项目涵盖了从基础的HTTP服务器到复杂的Servlet容器的...
手写 tomcat IDEA工程
11-07
在手写Tomcat时，你需要实现一个Servlet容器，管理Servlet的生命周期，包括加载、初始化、服务和销毁等阶段。 4. **静态资源与动态资源**：静态资源通常是HTML、CSS、JavaScript等文件，它们可以直接发送给客户端；...
手写嵌入式Tomcat
12-07
Tomcat是Apache软件基金会的一个开源项目，它是一个实现了Java Servlet和JavaServer Pages（JSP）规范的轻量级Web应用服务器。Tomcat以其小巧、高效和易用性而受到广大开发者的喜爱。 嵌入式Tomcat的核心思想是将...
tomcat+Servlet
m0_49102053的博客
05-02 789
tomcat服务器
tomcat使用，servlet
温故。的博客
05-16 341
文章目录javaWeb一、课程目标二、tomcat安装配置三、发布静态项目四、servlet4.1 创建动态web工程4.1.1 eclipse创建web工程4.1.2 idea创建web工程4.2 概念4.3 使用servlet接口实现服务的处理4.4 使用GenericServlet抽象类实现服务的处理4.5 使用Httpservlet抽象类实现服务的处理五、HttpServletRequest5.1 概念5.2 常用方法六、HttpServletResponse6.1 概念6.2 常用方法七、Serv
java_web tomcat可以访问servlet和网页的路径问题
weixin_52509741的博客
06-26 506
问题
Tomcat【调用Servlet与执行逻辑】
weiweicuit1224的博客
01-31 496
Tomcat【调用Servlet与执行逻辑】
Tomcat的应用、Servlet介绍与使用
weixin_47208494的博客
05-23 652
Tomcat应用服务器 1.创建web项目了,web项目它需要运行在服务器上面(web应用服务器) 2.本地需要安装web应用服务器 ​ 1)tomcat: Apache提供的开源的web应用服务器 ​ 使用并发量不很大的情况下,可以使用tomcat(理论并发访问量500个) ​ 目前tomcat版本:8.5 (针对get提交时候,8.0以上自动解决中文乱码) ​ tomcat的官网:https://tomcat.apache.org/ ​ 下
Tomcat运行正常，但是无法通过路径访问Servlet的解决方法
热门推荐
还没入门Java的博客
04-02 1万+
我们通常会遇到tomcat可以运行并且index.jsp文件可以正常在浏览器上显示，但是访问servlet路径却一直404，tomcat可以正常运行说明我们的tomcat路径没错但是网上的方法都是叫我们去重新配置tomcat，所以我自己有一些方法来解决，解决方法如下： 方法一 ......
servlet访问文件 用Tomcat访问servlet
你好，Java！的博客
07-14 1349
首先建立一个Properties文件 文件名是datadase.properties driver=com.mysql.jdbc.Driver username=root password=123456 url=jdbc:mysql://localhost:3306/jdbcstudy 获取properties文件的路径 out->artifacts->你自己的文件->f...
Tomcat和servlet
hnhroot的博客
04-30 4386
Tomcat： 个人理解就是部署服务端，相当于封装了socketServer，也是遵守了tcp协议，tomcat有如下目录： bin：脚本目录 ***** 启动脚本(启动服务器)：startup.bat 停止脚本(停止服务器)：shutdown.bat conf：配置文件目录 (config /configuration) ***** 核心配置文件：server.xml 用户权限配置文件：tomcat-users.xml 所...
手写tomcat代码
最新发布
07-28
手写Tomcat代码通常是指直接操作Tomcat服务器的底层组件，比如Servlet、JSP等，以及管理服务器的一些核心功能，如连接池、部署应用等。这需要对Java SE API、网络编程和Tomcat架构有深入理解。 以下是一个简单的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值