网络编程之自己动手写简易版tomcat机制

最新推荐文章于 2024-01-16 11:41:37 发布
最新推荐文章于 2024-01-16 11:41:37 发布
阅读量940 收藏 4
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35681797/article/details/82426054
版权

tomcat是Apache、Sun 和其他一些公司及个人共同开发而成。经常用于与并发性不高的中小型系统中。为了了解web编程我们对类似于tomcat的服务器软件进行初探析并且自己动手写简易版tomcat。

前面我们编写了网络编程多个客户端的相互交互程序。现在我们将浅谈一下与浏览器之间的交互。当然我们从最基础的http协议开始。http协议是在tcp协议上再次进行包装，是应用层间的协议。即在tcp的基础上再次添加了相关的 头信息以便识别。基础头信息如下：

GET / HTTP/1.1
Host: localhost:8888
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9

 

HTTP/1.1 200 OK
Server:bjsxt Server/0.0.1
Date:Thu Sep 06 08:59:11 GMT+08:00 2018
infoContent-type:text/html;charset=UTF-8
infoContent-Length:72

当然这只是get请求方式和应答的最基础头信息。

只要tcp传送数据的基础上添加应答信息头浏览器就可以识别，以下就是基础的应答编写：

public class HttpServer {
    private String HH="\r\n";
    private String KG=" ";
    private ServerSocket socket;
    public static void main(String[] args) {
        HttpServer server=new HttpServer();
        server.start();
    }
    private  void start() {
        try {
            socket=new ServerSocket(8888);
            this.recive();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private void recive() {
        
        try {
            StringBuffer msg=new StringBuffer();
            String string=null;
            Socket socket1=socket.accept();
            byte[] bytes=new byte[2048];
            
            
            int len =socket1.getInputStream().read(bytes);
            
            System.out.println(new String(bytes,0,len));
            String msg1=msg.toString().trim();
            System.out.println(msg1);
            String string2="<html>\r\n" + 
                    "  <head></head>\r\n" + 
                    "  <body>\r\n" + 
                    "李宣霖"+
                    "</body>" + 
                    "</html>";

StringBuffer respones=new StringBuffer();
            respones.append("HTTP/1.1").append(KG).append("200").append(KG).append("OK").append(HH);
            respones.append("Server:bjsxt Server/0.0.1").append(HH);
            respones.append("Date:").append(new Date()).append(HH);
            respones.append("Content-type:text/html;charset=UTF-8").append(HH);
            respones.append("Content-Length:").append(string2.length()).append(HH);
            respones.append(HH);
            respones.append(string2);
            System.out.println(respones.toString());
            BufferedWriter output=new BufferedWriter(new OutputStreamWriter(socket1.getOutputStream(),"UTF-8"));
            output.write(respones.toString());
            output.flush();
            output.close();
        } catch (IOException e) {
            
            e.printStackTrace();
        }
    }
}

当然在此基础上我们把请求和应答进行封装，这样在使用的时候就能够更加的清楚简单。同时呢当请求的时候具有相关的参数传递我们就需要在请求的数据上面进行拆分与分析，将传递的数据从请求报文中拆解出来并建立map<String,List>的对象进行存储信息以便查找。

相关编写如下：
 

public class Request {
    private Map<String, List<String>> map;

    private BufferedInputStream reader;
    private String requestInfo;
    private String url;
    private String content;
    public Request(InputStream input) {
        super();
        map=new HashMap<String, List<String>>();
        try {
            reader=new BufferedInputStream(input);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void request() {
        byte[] data=new byte[20480];
        try {
            int len=reader.read(data);
            requestInfo=new String(data, 0, len);
            System.out.println(requestInfo);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private  void getContent() {
        String method=requestInfo.substring(0,requestInfo.indexOf(" "));
        if(method.equalsIgnoreCase("get")) 
            content=requestInfo.substring(requestInfo.indexOf("?")-1,requestInfo.indexOf("HTTP/1.1"));    
        else 
            if(method.equalsIgnoreCase("psot")||method.equalsIgnoreCase("POST"))
            {
                content=requestInfo.substring(requestInfo.lastIndexOf("\r\n")+2,requestInfo.length());
                content=decode(content, "UTF-8");
            }
        get(content);
    }
    private void get(String content){
        StringTokenizer stringTokenizer =new StringTokenizer(content, "&");
        while(stringTokenizer.hasMoreTokens()) {
            String string=stringTokenizer.nextToken();
            String [] list=string.split("=");
            if(list.length==1)
            {
                list=Arrays.copyOf(list,2);
                list[1]=null;
            }
            for(int i=0;i<list.length-1;i++)
            {
                if(!map.containsKey(list[0]))
                {
                    ArrayList<String> list2=new ArrayList<String>();
                    list2.add(list[1]);
                    map.put(list[0], list2);
                    continue;
                }
                map.get(list[0]).add(list[1]);
            }
        }
    }
    private String decode(String value,String code) {

        try {
            return java.net.URLDecoder.decode(value,code);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    public List<String> getparam(String name){
        request();
        getContent();
        return map.get(name);
        }
}

response编写

public class Respones {
    private StringBuffer header;
    private static String BLANK=" ";
    private static String NWELINE="\r\n";
    private int len;
    private StringBuffer content;
    private BufferedWriter writer;
    public Respones(OutputStream writer) {
        header=new StringBuffer();
        content=new StringBuffer();
        len=0;
        try {
            this.writer=new BufferedWriter(new OutputStreamWriter(writer,"UTF-8"));
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    private void  header(int code) {
        String state=null;
        header.append("HTTP/1.1").append(BLANK).append(code).append(BLANK);
        switch(code) {
        case 200: state ="OK";break;
        case 404: state ="NOT FOUND";break;
        case 505: state ="SEVER ERROR";break;
        }
        header.append(state).append(NWELINE);
        header.append("Server:bjsxt Server/0.0.1").append(NWELINE);
        header.append("Date:").append(new Date()).append(NWELINE);
        header.append("Content-type:text/html;charset=UTF-8").append(NWELINE);
        header.append("Content-Length:").append(len).append(NWELINE);
        header.append(NWELINE);
        
         
    }
    void push(int code) {
        header(code);
        try {
            writer.append(header.toString());
            writer.append(content.toString());
            writer.flush();
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public  void printfln(String info) {
        content.append(info).append(NWELINE);
        len+=(info+NWELINE).length();
    }
}

为了可以多次处理来访请求我们要是用多线程，而每一个请求没必要都创建一个实现Runnable接口类（现阶段其实是可以的因为我们只写了一个相关的serverlet，为了能够使用多个Serverlet往下再说多态的使用）所以我们将创建的多线程内容提出封装到Dispatcher类中。

public class Dispatcher implements Runnable{
    private Request req;
    private Respones rep;
    private Socket socket;
    
    public Dispatcher() {
        super();
    }
    
    public void setSocket(Socket socket) {
        this.socket = socket;
        try {
            rep=new Respones(socket.getOutputStream());
            req =new Request(socket.getInputStream());
        } catch (IOException e) {
        }
    }

    public void run() {
       Serverlet serverlet;
    try {
        serverlet = new Serverlet();
        serverlet.service(req, rep);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
        rep.push(200);
        
    }

}

编写Serverlet处理类：

public class Serverlet {
    public void service(Request req,Respones rep) {
        List<String> list=req.getparam("username");
        
        StringBuffer string2=new StringBuffer("<html>\r\n" + 
                "  <head></head>\r\n" + 
                "  <body>\r\n");
        for(String tem:list) {
            string2.append(tem);
        }
        string2.append(
                "</body>" + 
                "</html>");
        rep.printfln(string2.toString());
    }
}
编写服务接收端：

public class HttpServer2 {
    private String HH="\r\n";
    private String KG=" ";
    private ServerSocket socket;
    public static void main(String[] args) {
        HttpServer2 server=new HttpServer2();
            server.start();    
    }
    private  void start() {
        try {
            socket=new ServerSocket(8888);
            this.recive();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private void recive() {
        Socket socket1;
            
            while(true) {
                try {
                    socket1 = socket.accept();
                    System.out.println(1);
                    Dispatcher serverlet02=new Dispatcher (socket1);                   

                    System.out.println(msg1);           
                    Thread thread =new Thread(serverlet02);
                    thread.start();
                    System.out.println("=========================================");
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }         
    }
    }
}

但是呢这样只能处理一个单一的serverlet无论请求端发什么带有username的参数的URL（localhost:8888/xxxx）都会只得到一个页面。因为处理serverlet只写了一个，而且在分发serverlet的Dispatcher类中我们写死了只生成创建的这一个serverlet类。所以需要在Dispatcher中生成的引用可以指向所有可以用的具体serverlet对象，这就要使用到父类。而具体的实现对象我们需要通过分析请求http头信息进行分析得到具体的对象。所以需要编写一个类用于得到具体的serverlet为了不使产生对象过多我们使用反射来进行创建对象。具体实现如下：

首先要有request和response的封装类：
 

public class Request {
    private Map<String, List<String>> map;

    private BufferedInputStream reader;
    private String requestInfo;
    private String url;
    private String content;
    public Request(InputStream input) {
        super();
        map=new HashMap<String, List<String>>();
        try {
            reader=new BufferedInputStream(input);
        } catch (Exception e) {
            e.printStackTrace();
        }
        request();
        getContent();
    }
    public void request() {
        byte[] data=new byte[20480];
        try {
            int len=reader.read(data);
            requestInfo=new String(data, 0, len);
            System.out.println(requestInfo);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private  void getContent() {
        String method=requestInfo.substring(0,requestInfo.indexOf(" "));
        
        if(method.equalsIgnoreCase("get")) 
        {
            if(!requestInfo.substring(0,requestInfo.indexOf("\r\n")).contains("?"))
                {
                    content=null;
                    url=requestInfo.substring(requestInfo.indexOf(" ")+1,requestInfo.indexOf("HTTP/1.1")).trim();
                }
            else {
            url=requestInfo.substring(requestInfo.indexOf(" ")+1,requestInfo.indexOf("?"));
            content=requestInfo.substring(requestInfo.indexOf("?")+1,requestInfo.indexOf("HTTP/1.1")).trim();    
            content=decode(content, "UTF-8");
            }
        }
        else 
            if(method.equalsIgnoreCase("post"))
            {
                url=requestInfo.substring(requestInfo.indexOf("/"),requestInfo.indexOf("HTTP/1.1")).trim();
                content=requestInfo.substring(requestInfo.lastIndexOf("\r\n")+2,requestInfo.length());
                content=decode(content, "UTF-8");
            }
        if(content!=null)
        get(content);
    }
    private void get(String content){
        StringTokenizer stringTokenizer =new StringTokenizer(content, "&");
        while(stringTokenizer.hasMoreTokens()) {
            String string=stringTokenizer.nextToken();
            String [] list=string.split("=");
            if(list.length==1)
            {
                list=Arrays.copyOf(list,2);
                list[1]=null;
            }
            for(int i=0;i<list.length-1;i++)
            {
                if(!map.containsKey(list[0]))
                {
                    ArrayList<String> list2=new ArrayList<String>();
                    list2.add(list[1]);
                    map.put(list[0], list2);
                    continue;
                }
                else
                     map.get(list[0]).add(list[1]);
            }
        }
    }
    private String decode(String value,String code) {

        try {
            return java.net.URLDecoder.decode(value,code);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    public List<String> getparam(String name){
        return map.get(name);
        }
    public String getUrl() {
        
        return url;
    }
}

public class Respones {
    private StringBuffer header;
    private static String BLANK=" ";
    private static String NWELINE="\r\n";
    private int len;
    private StringBuffer content;
    private BufferedWriter writer;
    public Respones(OutputStream writer) {
        header=new StringBuffer();
        content=new StringBuffer();
        len=0;
        try {
            this.writer=new BufferedWriter(new OutputStreamWriter(writer,"UTF-8"));
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    private void  header(int code) {
        String state=null;
        header.append("HTTP/1.1").append(BLANK).append(code).append(BLANK);
        switch(code) {
        case 200: state ="OK";break;
        case 404: state ="NOT FOUND";break;
        case 505: state ="SEVER ERROR";break;
        }
        header.append(state).append(NWELINE);
        header.append("Server:bjsxt Server/0.0.1").append(NWELINE);
        header.append("Date:").append(new Date()).append(NWELINE);
        header.append("Content-type:text/html;charset=UTF-8").append(NWELINE);
        header.append("Content-Length:").append(len).append(NWELINE);
        header.append(NWELINE);
        
         
    }
    void push(int code) {
        header(code);
        try {
            writer.append(header.toString());
            writer.append(content.toString());
            writer.flush();
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public  void printfln(String info) {
        content.append(info).append(NWELINE);
        len+=(info+NWELINE).length();
    }
}
然后定义serverlet父类：

public abstract class Serverlet {
    public void service(Request req,Respones rep) throws Exception{
        this.doGet(req,rep);
        this.doPost(req,rep);
    }
    public abstract void doGet(Request req,Respones rep);
    public abstract void doPost(Request req,Respones rep);
}
具体的实现类

public class LoginServerlet extends Serverlet {
    private int num=10;

    @Override
    public void doGet(Request req, Respones rep) {
        num--;
        List<String> list=req.getparam("username");
        List<String> list1=req.getparam("password");
        
        StringBuffer string2=new StringBuffer("<html>\r\n" +
            "  <head></head>\r\n" +                 "  <body>\r\n");
    for(String tem:list) {            
        string2.append(tem);
    }
    for(String tem:list1) {            
        string2.append(tem);
    }
    string2.append(    num+            
        "</body>" + 
        "</html>");
        rep.printfln(string2.toString());
        
    }
    
    @Override
    public void doPost(Request req, Respones rep) {
}
}

public class RegisterServerlet extends Serverlet{

    @Override
    public void doGet(Request req, Respones rep) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void doPost(Request req, Respones rep) {
        // TODO Auto-generated method stub
        
    }}
之后写分发的Dispatcher类

public class Dispatcher implements Runnable{
    private Request req;
    private Respones rep;
    private Socket socket;
    
    public Dispatcher() {
        super();
    }
    
    public void setSocket(Socket socket) {
        this.socket = socket;
        try {
            rep=new Respones(socket.getOutputStream());
            req =new Request(socket.getInputStream());
        } catch (IOException e) {
        }
    }

    public void run() {
       Serverlet serverlet;
    try {
        serverlet = WebApp.getServer(req.getUrl());//通过url来找具体的类名然后通过WebApp的getServer创建处理该请求serverlet的类
        serverlet.service(req, rep);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
        rep.push(200);
        
    }

}

编写能够创建具体的serverlet类：

public class WebApp {
    private  static ServerContext serverContext;
    private static Map<String,Serverlet> map;
    static {
        serverContext=new ServerContext();//我们需要将所有serverlet的能够处理请求的url写入到一个map中然后多个请求url可以对应一个serverlet，并且可以对serverlet取别名（为以后的注解准备）在创建一个map放别名和对应的serverlet。然后进行封装。
        Map<String, String > maping=serverContext.getMaping();
        maping.put("/log", "login");
        maping.put("/login", "login");
        maping.put("/favicon.ico","login");
        maping.put("/register", "register");
        Map<String, String> serverlet=serverContext.getServerlet();
        serverlet.put("login", "httpserver02.LoginServerlet");
        serverlet.put("register", "httpserver02.RegisterServerlet");
         map=new HashMap<String, Serverlet>();
    }
    public static Serverlet getServer(String url) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<?> serverlet=Class.forName(serverContext.getServerlet().get(serverContext.getMaping().get(url)));
        
        if(map.get(url)==null)        
            map.put(url, (Serverlet)serverlet.newInstance());
        return map.get(url);
    }
}

封装的两个map类：

public class ServerContext {
    private Map<String, String> maping;
    private Map<String, String> serverlet;
    
    public ServerContext() {
        maping=new HashMap<String, String>();
        serverlet=new HashMap<String, String>();
    }
    public Map<String, String> getMaping() {
        return maping;
    }
    public void setMaping(Map<String, String> maping) {
        this.maping = maping;
    }
    public Map<String, String> getServerlet() {
        return serverlet;
    }
    public void setServerlet(Map<String, String> serverlet) {
        this.serverlet = serverlet;
    }
    
}

服务类：
public class Server {
    private ServerSocket socket;
    public static void main(String[] args) {
        Server server=new Server();
            server.start();    
    }
    private  void start() {
        try {
            socket=new ServerSocket(8888);
            this.recive();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private void recive() {
        Socket socket1;
            Dispatcher dispatcher=new Dispatcher();
            while(true) {
                try {
                    
                    socket1=socket.accept();
                    if(socket1!=null)
                        dispatcher.setSocket(socket1);
                    new Thread(dispatcher).start();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }                
       }
    }
}

所以呢最终我们只要继承serverlet然后在service方法中写相关的输出字符串就行了。

qq_35681797
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
diytomcat:跟着站长写的一个diyTomcat，写这个项目的主要目的是为了巩固java基础，同时也是为了将来读Tomcat源码做基础准备。这个项目会不断更新以及改进。
03-23
假猫 跟着站长写的一个diyTomcat，写这个项目的主要目的是为了巩固java基础，同时也是为了将来读Tomcat源码做基础准备。这个项目会不断更新以及改进。站长使用的是Java工具hutool，我认为直接使用hutool工具不利于对java的基本类的使用（我还是一个小萌新），在做完整个项目后，我会重构该项目使用的java的基本类库来重新做一下diyTomcat原文链接：
自制简易Tomcat服务器
haohulala的博客
12-26 1049
在学习javaweb的时候我感觉自己是很懵逼的，因为好像就是写servlet然后配置web.xml，就可以让服务器提供服务了，对于这整个过程都不是很了解。为了弄懂整个的过程，我就找了黑马的自制简易Tomcat的视频，现将代码记录与这篇文章中。相信你看完整个过程，会对javaweb有更深的理解 模拟浏览器给服务器发送请求 // 模拟浏览器向服务器发送HTTP请求 public class TestClient { private static Socket socket = null;
Java 编程实战：如何用 Java 编写一个简单而强大的 Tomcat
TaloyerG的博客
08-08 2035
本文介绍了如何使用 Java 编写 Tomcat，并实现一个简单的 Web 服务器和 Servlet 容器。本文还介绍了 Tomcat 的基本框架和相关配置，并使用 Eclipse 进行开发和调试。本文旨在帮助伙伴们理解和掌握 Tomcat 的原理和用法。Tomcat 是一个开源的 Web 服务器和 Servlet 容器，它可以提供动态 Web 内容的处理和交互功能。Tomcat 是用 Java 语言编写的，需要运行在 Java 虚拟机上，所以它可以跨平台运行，并且可以与其他 Java 技术集成。
自定义Tomcat
AN_ERA的博客
12-01 1454
一、Tomcat_v1 Tomcat服务器本质上就是一个 Server的程序，所以这里我们先写一个Server的程序和Socket程序，先完成最基本的通讯功能 Server.java: package com.tomcat_v1.mySocket_v1; import java.io.IOException; import java.io.InputStream; import java...
手写一个简单的tomcat(从零到一，简单易懂)
最新发布
比时代快才是快，趁风使柁
01-16 961
教你从零到一构建一个简易的tomcat，获取请求，解析请求，响应资源，刚接触tomcat，本文章是非常适合的，欢迎小伙伴们学习留言交流哦！！！
java学习CS架构网络编程；简易模拟tomcat服务器项目源码.zip
06-14
简易模拟tomcat服务器项目源码java学习CS架构网络编程；简易模拟tomcat服务器项目源码java学习CS架构网络编程；简易模拟tomcat服务器项目源码java学习CS架构网络编程；简易模拟tomcat服务器项目源码java学习CS架构...
MOOC网络编程实践期末（实现自己的Tomcat）
05-12
这是中国大学MOOC网络编程实践课程的期末作业（实现自己的Tomcat），实现的是第五难度，里面有详细的截图，可以参考
自己动手写Tomcat
08-04
NULL 博文链接：https://09094224.iteye.com/blog/2023841
自己实现Tomcat-完善版
06-24
该包含Mytomcat源码和Mytomcat使用安装包。MyTomcat.zip是使用文件，就像我们下的tomcat一样 解压后，配置环境变量MT_HOME 然后启动服务器即可 里面有测试文件.....
Java网络编程&Tomcat7&MyEclipse10
10-14
附件包含Java网络编程基础详解，如UDP发送端接收端聊天、TCP客户端服务端上传下载等。关于Tomcat7绿色版下载安装，MyEclipse10安装及部署Tomcat，见我的博文：...
如何自己动手写一个 Tomcat
Just do it
05-03 1536
最近刚好工作中有遇到一个安全问题，IE 在 URL 地址栏中输入 < 这种特殊字符的时候，将会抛出异常打印异常堆栈信息，这样你的系统是不安全的，而且即使你在项目中使用了拦截器、过滤器等进行拦截都没用办法处理。原因是<并没有进入我们自己的web应用而是在中间间层tomcat容器就已经报错了。原因tomcat8.5.30之后拦截特殊字符解决办法 待续… ...
手写Tomcat
书生的博客
10-27 3063
tomcat提供的服务： 第一：提供Socket服务 第二：进行请求的分发 第三：需要把请求和响应封装成request/response
从 0 开始手写一个Tomcat，7 步搞定！
Walker_zmc的博客
01-27 401
作者：张丰哲 来源：www.jianshu.com/p/dce1ee01fb90   Tomcat，这只3脚猫，大学的时候就认识了，直到现在工作中，也常会和它打交道。这是一只神奇的猫，今天让我来抽象你，实现你！ Tomcat 是非常流行的 Web Server，它还是一个满足 Servlet 规范的容器。那么想一想，Tomcat 和我们的 Web 应用是什么关系？   从感性上来说...
5分钟学会Tomcat
QQ_____365392777的博客
08-14 177
本文主要讲解了Tomcat的下载安装以及配置，解决了乱码，闪退的小问题，最后使用它部署了一张图片，从而理解它的工作原理，我是编程，如果觉得文章写的不错，记得三联支持可怜的博主呀 👋。...
Tomcat简介及常见问题
wangyanming123的博客
05-18 1178
Tomcat简介及常见问题
手把手系列—手写tomcat
qq_60969145的博客
09-29 721
今天一起徒手创建了一个精简版的tomcat，相信大家对tomcat运行原理会有更加深入的理解java注解、反射java网络编程servlet基础。Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应（下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你
Tomcat
weixin_69620038的博客
02-04 72
Tomcat简单的说就是一个运行JAVA的网络服务器，底层是Socket的一个程序，它也是JSP和Serlvet的一个容器。需求：我有多个html文件，想把其中的一个html文件作为我web站点的首页。没有WEB-INF目录下的web.xml文件支持，是无法解决我的需求的。如果你学过html，css，你会知道你写的页面只能自己访问，jsp被访问后生成对应的server文件和.class文件。提供能够让别人访问自己写的页面的一个程序。别人不能远程访问你写的页面。web站点的目录是有规范的。
自动动手写Tomcat
Michael Wing's workspace
06-28 1286
最近研究一方socket编程，由于想动手写关于socket方面的东西。然而我们知道通过URL去访问某网址，其实其底层用的就是socket，于是我就写了一个很简单的tomcat服务器，主要目地在于学习，在此分享给大家。同时提供下载源工程。   我写的工程用Maven管理的，但是我没有引入其它的JAR包，为此我就不列出pom.xml文件了。 在此简要地说明每个类的作用：   Server.j
自己动手编写tomcat服务器(一)
wenjingyu的专栏
08-22 9394
这篇博文来自于《how tomcat works》一书的第一章 我们的服务器程序由下列三个类组成：      HttpServer.java      Request.java      Response.java HttpServer.java是程序的入口。它的main方法创建了一个HttpServer的实例，然后调用它的await方法，此方法等待客户端的 HTTP请求，处理请求
帮我写一个简易的tomcat
04-01
要编写一个简易的Tomcat，您需要了解以下几个方面： 1. Servlet容器：Tomcat是一个Servlet容器，它可以运行和管理Java Servlet和JSP程序。因此，您需要实现一个Servlet容器，其中包括解析HTTP请求、创建和管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值