第二章 一个简单的servlet服务器

最新推荐文章于 2022-04-15 00:43:06 发布
最新推荐文章于 2022-04-15 00:43:06 发布
阅读量706 收藏 1
点赞数 1
分类专栏： how tomcat works 笔记 文章标签： servlet实例 tomcat howtomcatw
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/disiwei1012/article/details/53573891
版权

一、程序1

在这个例子中，可以同时处理静态文件，和servlet请求。

一个全功能的servlet容器会为servlet的每个请求HTTP请求做下面工作：

  1. 当第一次调用servlet的时候，加载该servlet类并调用servlet的init方法（仅仅一次）。
  2. 对每次请求，构建一个request和response实例。
  3. 当调用servlet的service方法，同时传递request和response对象。
  4. 当servlet类被关闭的时候，调用servlet的destroy方法并卸载servlet类。

本程序能做的事情：

  1. 等待HTTP请求。
  2. 构造一个ServletRequest和一个ServletResponse对象。
  3. 假如该请求需要一个静态资源的话，调用staticResourceProcessor实例的process方法，同时传递SerletResponse和ServletRequest对象。
  4. 假如该请求需要一个servlet的话，加载servlet类并调用servlet的service方法，同时传递ServletRequest,ServletResponse对象。

时序图如下：
这里写图片描述

HttpServlet1类：

package ex02;

import java.net.Socket;

public class HttpServer1 {

  private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";

  private boolean shutdown = false;

  public static void main(String[] args) {
    HttpServer1 server = new HttpServer1();
    server.await();
  }

  public void await() {
    ServerSocket serverSocket = null;
    int port = 8080;
    try {
      serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    }
    catch (IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    while (!shutdown) {
      Socket socket = null;
      InputStream input = null;
      OutputStream output = null;
      try {
        socket = serverSocket.accept();
        input = socket.getInputStream();
        output = socket.getOutputStream();

        Request request = new Request(input);
        request.parse();

        Response response = new Response(output);
        response.setRequest(request);

        if (request.getUri().startsWith("/servlet/")) {
          ServletProcessor1 processor = new ServletProcessor1();
          processor.process(request, response);
        }
        else {
          StaticResourceProcessor processor = new StaticResourceProcessor();
          processor.process(request, response);
        }

        socket.close();
        shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
      }
      catch (Exception e) {
        e.printStackTrace();
        System.exit(1);
      }
    }
  }
}

Request类：

package ex02;

import java.io.InputStream;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

import javax.servlet.AsyncContext;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;


public class Request implements ServletRequest {

  private InputStream input;
  private String uri;

  public Request(InputStream input) {
    this.input = input;
  }

  public String getUri() {
    return uri;
  }

  private String parseUri(String requestString) {
    int index1, index2;
    index1 = requestString.indexOf(' ');
    if (index1 != -1) {
      index2 = requestString.indexOf(' ', index1 + 1);
      if (index2 > index1)
        return requestString.substring(index1 + 1, index2);
    }
    return null;
  }

  public void parse() {
    // Read a set of characters from the socket
    StringBuffer request = new StringBuffer(2048);
    int i;
    byte[] buffer = new byte[2048];
    try {
      i = input.read(buffer);
    }
    catch (IOException e) {
      e.printStackTrace();
      i = -1;
    }
    for (int j=0; j<i; j++) {
      request.append((char) buffer[j]);
    }
    System.out.print(request.toString());
    uri = parseUri(request.toString());
  }

  /* implementation of the ServletRequest*/
  public Object getAttribute(String attribute) {
    return null;
  }

  public Enumeration getAttributeNames() {
    return null;
  }

  public String getRealPath(String path) {
    return null;
  }

  public RequestDispatcher getRequestDispatcher(String path) {
    return null;
  }

  public boolean isSecure() {
    return false;
  }

  public String getCharacterEncoding() {
    return null;
  }

  public int getContentLength() {
    return 0;
  }

  public String getContentType() {
    return null;
  }

  public ServletInputStream getInputStream() throws IOException {
    return null;
  }

  public Locale getLocale() {
    return null;
  }

  public Enumeration getLocales() {
    return null;
  }

  public String getParameter(String name) {
    return null;
  }

  public Map getParameterMap() {
    return null;
  }

  public Enumeration getParameterNames() {
    return null;
  }

  public String[] getParameterValues(String parameter) {
    return null;
  }

  public String getProtocol() {
    return null;
  }

  public BufferedReader getReader() throws IOException {
    return null;
  }

  public String getRemoteAddr() {
    return null;
  }

  public String getRemoteHost() {
    return null;
  }

  public String getScheme() {
   return null;
  }

  public String getServerName() {
    return null;
  }

  public int getServerPort() {
    return 0;
  }

  public void removeAttribute(String attribute) {
  }

  public void setAttribute(String key, Object value) {
  }

  public void setCharacterEncoding(String encoding)
    throws UnsupportedEncodingException {
  }

@Override
public AsyncContext getAsyncContext() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public DispatcherType getDispatcherType() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public String getLocalAddr() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public String getLocalName() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public int getLocalPort() {
    // TODO Auto-generated method stub
    return 0;
}

@Override
public int getRemotePort() {
    // TODO Auto-generated method stub
    return 0;
}

@Override
public ServletContext getServletContext() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public boolean isAsyncStarted() {
    // TODO Auto-generated method stub
    return false;
}

@Override
public boolean isAsyncSupported() {
    // TODO Auto-generated method stub
    return false;
}

@Override
public AsyncContext startAsync() throws IllegalStateException {
    // TODO Auto-generated method stub
    return null;
}

@Override
public AsyncContext startAsync(ServletRequest servletRequest,
        ServletResponse servletResponse) throws IllegalStateException {
    // TODO Auto-generated method stub
    return null;
}


}

Response类：

package ex02;

import java.io.OutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.File;
import java.io.PrintWriter;
import java.util.Locale;
import javax.servlet.ServletResponse;
import javax.servlet.ServletOutputStream;

public class Response implements ServletResponse {

  private static final int BUFFER_SIZE = 1024;
  Request request;
  OutputStream output;
  PrintWriter writer;

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

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

  public void sendStaticResource() throws IOException {
    byte[] bytes = new byte[BUFFER_SIZE];
    FileInputStream fis = null;
    try {
      File file = new File(Constants.WEB_ROOT, request.getUri());
      fis = new FileInputStream(file);
      int ch = fis.read(bytes, 0, BUFFER_SIZE);
      while (ch!=-1) {
        output.write(bytes, 0, ch);
        ch = fis.read(bytes, 0, BUFFER_SIZE);
      }
    }
    catch (FileNotFoundException e) {
      String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
        "Content-Type: text/html\r\n" +
        "Content-Length: 23\r\n" +
        "\r\n" +
        "<h1>File Not Found</h1>";
      output.write(errorMessage.getBytes());
    }
    finally {
      if (fis!=null)
        fis.close();
    }
  }

  public void flushBuffer() throws IOException {
  }

  public int getBufferSize() {
    return 0;
  }

  public String getCharacterEncoding() {
    return null;
  }

  public Locale getLocale() {
    return null;
  }

  public ServletOutputStream getOutputStream() throws IOException {
    return null;
  }

  public PrintWriter getWriter() throws IOException {
    writer = new PrintWriter(output, true);
    return writer;
  }

  public boolean isCommitted() {
    return false;
  }

  public void reset() {
  }

  public void resetBuffer() {
  }

  public void setBufferSize(int size) {
  }

  public void setContentLength(int length) {
  }

  public void setContentType(String type) {
  }

  public void setLocale(Locale locale) {
  }

    @Override
    public String getContentType() {
        return null;
    }

    @Override
    public void setCharacterEncoding(String charset) {

    }
}

StaticResourceProcessor类：

package ex02;

import java.io.IOException;

public class StaticResourceProcessor {

  public void process(Request request, Response response) {
    try {
      response.sendStaticResource();
    }
    catch (IOException e) {
      e.printStackTrace();
    }
  }
}

ServletProcessor1类：
需要注意的是：加载类的时候，别忘了加上包名。 

package ex02;

import java.net.URL;

public class ServletProcessor1 {

  public void process(Request request, Response response) {

    String uri = request.getUri();
    String servletName = uri.substring(uri.lastIndexOf("/") + 1);
    URLClassLoader loader = null;

    try {
      URL[] urls = new URL[1];
      URLStreamHandler streamHandler = null;
      File classPath = new File(Constants.WEB_ROOT);
      String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
      System.out.println("repository-->"+repository);
      urls[0] = new URL(null, repository, streamHandler);
      loader = new URLClassLoader(urls);
    }
    catch (IOException e) {
      System.out.println(e.toString() );
    }
    Class myClass = null;
    try {
      myClass = loader.loadClass("ex02."+servletName);
    }
    catch (ClassNotFoundException e) {
      System.out.println(e.toString());
    }

    Servlet servlet = null;

    try {
      servlet = (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) request, (ServletResponse) response);
    }
    catch (Exception e) {
      System.out.println(e.toString());
    }
    catch (Throwable e) {
      System.out.println(e.toString());
    }

  }
}

PrimitiveServlet类：

package ex02;

import java.io.IOException;  
import java.io.PrintWriter;  

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class PrimitiveServlet implements Servlet {  


  public void init(ServletConfig config) throws ServletException {  
    System.out.println("init");  
  }  

  public void service(ServletRequest request, ServletResponse response)  
    throws ServletException, IOException {  
    System.out.println("from service");  
    PrintWriter out = response.getWriter();  
    out.println("Hello. Roses are red.");  
    out.print("Violets are blue.");  
  }  


  public void destroy() {  
    System.out.println("destroy");  
  }  


  public String getServletInfo() {  
    return null;  
  }  
  public ServletConfig getServletConfig() {  
    return null;  
  }  

}

结果：
http://localhost:8080/staticfile.txt
这里写图片描述

http://localhost:8080/servlet/PrimitiveServlet
这里写图片描述

二、程序二

对于书中的“在 ServletProcessor1 类的 process 方法，你向上转换ex02.pyrmont.Request 实例为 javax.servlet.ServletRequest ，并作为第一个参数传递给servlet 的 service 方 法 。 你 也 向 下 转 换 ex02.pyrmont.Response 实 例 为javax.servlet.ServletResponse，并作为第二个参数传递给 servlet 的 service 方法，这会危害安全。”不是很理解，暂不追究，等有时间再来看。

HttpServer2

package chapter02.exe01;

import java.net.Socket;
import java.net.ServerSocket;
import java.net.InetAddress;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

public class HttpServer2 {

  private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";

  private boolean shutdown = false;

  public static void main(String[] args) {
    HttpServer2 server = new HttpServer2();
    server.await();
  }

  public void await() {
    ServerSocket serverSocket = null;
    int port = 8801;
    try {
      serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    }
    catch (IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    while (!shutdown) {
      Socket socket = null;
      InputStream input = null;
      OutputStream output = null;
      try {
        socket = serverSocket.accept();
        input = socket.getInputStream();
        output = socket.getOutputStream();

        Request request = new Request(input);
        request.parse();

        Response response = new Response(output);
        response.setRequest(request);

        if (request.getUri().startsWith("/servlet/")) {
          ServletProcessor2 processor = new ServletProcessor2();
          processor.process(request, response);
        }
        else {
          StaticResourceProcessor processor = new StaticResourceProcessor();
          processor.process(request, response);
        }

        socket.close();
        shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
      }
      catch (Exception e) {
        e.printStackTrace();
        System.exit(1);
      }
    }
  }
}

ServletProcessor2

package chapter02.exe01;

import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import java.io.File;
import java.io.IOException;
import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ServletProcessor2 {

  public void process(Request request, Response response) {

    String uri = request.getUri();
    String servletName = uri.substring(uri.lastIndexOf("/") + 1);
    URLClassLoader loader = null;

    try {
      URL[] urls = new URL[1];
      URLStreamHandler streamHandler = null;
      File classPath = new File(Constants.WEB_ROOT);
      String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
      urls[0] = new URL(null, repository, streamHandler);
      loader = new URLClassLoader(urls);
    }
    catch (IOException e) {
      System.out.println(e.toString() );
    }
    Class myClass = null;
    try {
      myClass = loader.loadClass(servletName);
    }
    catch (ClassNotFoundException e) {
      System.out.println(e.toString());
    }

    Servlet servlet = null;
    RequestFacade requestFacade = new RequestFacade(request);
    ResponseFacade responseFacade = new ResponseFacade(response);
    try {
      servlet = (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
    }
    catch (Exception e) {
      System.out.println(e.toString());
    }
    catch (Throwable e) {
      System.out.println(e.toString());
    }

  }
}

RequestFacade

package chapter02.exe01;

import java.io.IOException;
import java.io.BufferedReader;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;

public class RequestFacade implements ServletRequest {

  private ServletRequest request = null;

  public RequestFacade(Request request) {
    this.request = request;
  }

  public Object getAttribute(String attribute) {
    return request.getAttribute(attribute);
  }

  public Enumeration getAttributeNames() {
    return request.getAttributeNames();
  }

  public String getRealPath(String path) {
    return request.getRealPath(path);
  }

  public RequestDispatcher getRequestDispatcher(String path) {
    return request.getRequestDispatcher(path);
  }

  public boolean isSecure() {
    return request.isSecure();
  }

  public String getCharacterEncoding() {
    return request.getCharacterEncoding();
  }

  public int getContentLength() {
    return request.getContentLength();
  }

  public String getContentType() {
    return request.getContentType();
  }

  public ServletInputStream getInputStream() throws IOException {
    return request.getInputStream();
  }

  public Locale getLocale() {
    return request.getLocale();
  }

  public Enumeration getLocales() {
    return request.getLocales();
  }

  public String getParameter(String name) {
    return request.getParameter(name);
  }

  public Map getParameterMap() {
    return request.getParameterMap();
  }

  public Enumeration getParameterNames() {
    return request.getParameterNames();
  }

  public String[] getParameterValues(String parameter) {
    return request.getParameterValues(parameter);
  }

  public String getProtocol() {
    return request.getProtocol();
  }

  public BufferedReader getReader() throws IOException {
    return request.getReader();
  }

  public String getRemoteAddr() {
    return request.getRemoteAddr();
  }

  public String getRemoteHost() {
    return request.getRemoteHost();
  }

  public String getScheme() {
   return request.getScheme();
  }

  public String getServerName() {
    return request.getServerName();
  }

  public int getServerPort() {
    return request.getServerPort();
  }

  public void removeAttribute(String attribute) {
    request.removeAttribute(attribute);
  }

  public void setAttribute(String key, Object value) {
    request.setAttribute(key, value);
  }

  public void setCharacterEncoding(String encoding)
    throws UnsupportedEncodingException {
    request.setCharacterEncoding(encoding);
  }

public String getLocalAddr() {
    // TODO Auto-generated method stub
    return null;
}

public String getLocalName() {
    // TODO Auto-generated method stub
    return null;
}

public int getLocalPort() {
    // TODO Auto-generated method stub
    return 0;
}

public int getRemotePort() {
    // TODO Auto-generated method stub
    return 0;
}

}

ResponseFacade

package chapter02.exe01;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Locale;
import javax.servlet.ServletResponse;
import javax.servlet.ServletOutputStream;

public class ResponseFacade implements ServletResponse {

  private ServletResponse response;
  public ResponseFacade(Response response) {
    this.response = response;
  }

  public void flushBuffer() throws IOException {
    response.flushBuffer();
  }

  public int getBufferSize() {
    return response.getBufferSize();
  }

  public String getCharacterEncoding() {
    return response.getCharacterEncoding();
  }

  public Locale getLocale() {
    return response.getLocale();
  }

  public ServletOutputStream getOutputStream() throws IOException {
    return response.getOutputStream();
  }

  public PrintWriter getWriter() throws IOException {
    return response.getWriter();
  }

  public boolean isCommitted() {
    return response.isCommitted();
  }

  public void reset() {
    response.reset();
  }

  public void resetBuffer() {
    response.resetBuffer();
  }

  public void setBufferSize(int size) {
    response.setBufferSize(size);
  }

  public void setContentLength(int length) {
    response.setContentLength(length);
  }

  public void setContentType(String type) {
    response.setContentType(type);
  }

  public void setLocale(Locale locale) {
    response.setLocale(locale);
  }

public String getContentType() {
    // TODO Auto-generated method stub
    return null;
}

public void setCharacterEncoding(String arg0) {
    // TODO Auto-generated method stub

}

}
javaduqing
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Servlet从入门到精通
cgblpx的博客
11-14 1万+
文章目录一,Servlet--1,概述--2,准备工作在IDEA里创建一个web工程整理web工程目录结构修改资源输出位置修改jar包存放位置配置Tomcat服务器--3,入门案例思路创建Servlet程序配置web.xml文件测试--4,Servlet的继承结构标题 一,Servlet –1,概述 Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成 动态
Servlet——服务器端小型java应用程序
malaganguo的博客
07-30 1803
Servlet基本内容 Servlet通过Http协议接收和响应来自客户端的请求。 实际开发中我们创建Servlet类的话直接在eclipse中创建Servlet就很便捷，IDE工具会自动帮我们继承HttpServlet类，并且下面会给出覆写类的选项，根据需要选择需要覆写的类比较方便。 点击next会来到xml文件的配置选项页面： 可以看到我们可以填写Servlet名字、映射路径、...
Servlet服务最全入门笔记（包含案例）
PIKapikaaaa的博客
04-15 579
servlet最全入门笔记啊 Http协议 生命周期 进化史 处理请求 转发与重定向
使用servlet的简单服务器demo
03-19
使用servlet的简单服务器demo，有get与post的响应，支持注册与登录两个请求。
servlet简单示例+调用webservice服务
一个向往文艺的滴塑青年的博客
01-16 8947
servle的简单示例，servlet调用web服务。
第19章 Tomcat服务器和Servlet.pdf
01-11
【第19章 Tomcat服务器和Servlet】 一、引言 1.1 C/S架构和B/S架构 C/S架构（Client/Server）是早期的一种软件架构方式，它需要在客户端安装特定软件来与服务器进行交互。优点在于图形界面表现力强，如3D游戏，但...
一个简单的servlet容器
04-02
本主题将深入探讨“一个简单的Servlet容器”的实现，参考自《深入剖析Tomcat》这本书的第二章。 Servlet容器的主要职责是接收HTTP请求，然后调用相应的Servlet来处理这些请求，并将Servlet的响应返回给客户端。在...
Javaweb第二章代码
04-17
在"Javaweb第二章代码"中，我们可以期待学习到关于Servlet、JSP（JavaServer Pages）、JDBC（Java Database Connectivity）以及MVC（Model-View-Controller）设计模式等核心概念和实践。 Servlet是JavaWeb的基础，...
How Tomcat Work 第二章 实例应用
08-10
《How Tomcat Work 第二章 实例应用》深入解析 在深入探讨Tomcat工作原理之前，我们先要了解什么是Tomcat。Apache Tomcat是一款开源的Java Servlet容器，它实现了Java Servlet和JavaServer Pages (JSP) 规范，是...
译How Tomcat Works(第二章)
03-18
《译How Tomcat Works(第二章)》这篇文章主要讲解了Apache Tomcat服务器的工作原理，它是一个开源的Java Servlet容器，广泛用于部署Web应用程序。在这一章中，我们将深入探讨Tomcat如何处理HTTP请求，以及其内部架构...
Servlet，web服务器
hellojoy的博客
01-08 1419
Web服务器是运行及发布Web应用的容器，只有将开发的Web项目放置到该容器中，才能使网络中的所有用户通过浏览器进行访问。开发Java Web应用所采用的服务器主要是与JSP/Servlet兼容的Web服务器，比较常用的有Tomcat、Resin、JBoss、WebSphere 和 WebLogic 等。 1、Tomcat 服务器 目前非常流行的Tomcat服务器是Apache-Jarkart...
什么是Servlet容器？
热门推荐
young4u
01-19 2万+
在本文中，我写了一些关于Web服务器、Servlet容器以及它与JVM的关系的基本概念。我想表达的是，Servlet容器也仅仅不过是一个Java程序。 1. 什么是Web服务器？     想要知道什么是Servlet容器，我们首先要知道什么是Web服务器。     Web服务器使用HTTP协议来传输数据。最简单的一种情况是，用户在浏览器（客户端，client）中输入一个URL（如，w
servlet服务程序
wang1992_1992的博客
07-10 899
servlet请求路径的问题 在form的action属性中，直接写servlet的url路径，默认是在当前目录下查找，一旦网页在子目录中，那么会在提交路径中加上子目录的名称，可以通过../回到上一级目录。 如果目录比较深，频繁用../很繁琐，而且一移植性不好，可以在url路径中，以/开始，表示回到webapps根目录，再加上部署名，在书写servlet请求路径 form action = "
根据接口文档书写接口，并在前端调用接口返回显示出数据（加下载）
weixin_30687587的博客
11-28 2700
---恢复内容开始--- 1.首先来看接口文档（其中一个接口）： 接口的编写： 1 /** 2 * 7.11 余额明细查询接口 3 * 4 * @param token 5 * @param pageNum 6 * 非必填 分页查询当前页数，默认为 1 7 * ...
Web Service和Servlet的区别
渴望，就奋力追寻...
03-01 1万+
在最开始学习Web Service时候，总觉得Web Service和Servlet没有什么区别，觉得Servlet可以对Http请求进行相应并返回数据，而Web Service只不过是基于SOAP协议和XML对数据进行封装了，也是采用Http协议来传输数据，后来通过慢慢阅读相关材料，加上实际操作，才发现Web Service和Servlet有很大区别，根本不是在一个层次上的东西，于是对于它们的区
服务端之Servlet介绍
码说芯语的博客
07-02 221
1、Servlet: Tomcat中的一个组件，可以接受前端发送的请求，能够从请求中获取参数，可以调用数据库，响应数据给前端。 2、Tomca中的主要组件： （1）Fillter组件（过滤器） （2）JSP组件，JSP即java server Page动态页面，非前后端分离的模式下，Html+java=index.jsp （3）Servlet组件 （4）Listener监听器组件:监听容器启动或者关闭，还可以监听Session做在线人数统计 3、Tomca中四大组件的工作原理： ...
servlet容器，web服务器的区别与联系
SprintMan的博客
11-11 2749
web服务器 无论网站规模的大小，最起码的工作就是要在用做Web服务器的计算机上安装某种Web服务器软件。只要在一台计算机上安装了Web服务器软件，从功能上讲，这台计算机就可以成为Web服务器。Web服务器包括硬件即计算机和软件即Web服务器软件两层意思。目前有两种Web服务器软件：IIS和Apache，但是它们都不直接支持Servlet和Jsp程序。要想在这些Web服务器软件中运行Servlet
Servlet一个最简单的例子（一）
thesnowball的专栏
07-22 2387
今天开始看Head First Servlet&JSP这本书，这本书文字和图片混合，看着比较轻松。然后刚开始学习，先写一个最简单的Servlet例子。   1：首先在Eclipse里面创建一个项目，然后需要配置web.xml文件，写一个Servlet的java类。具体的文件路径如下图： 2：首先看看web.xml里面的代码，这里主要配置一个servlet，servlet-class就是
第三章 Servlet 编程.ppt
最新发布
10-27
Java EE编程技术课程课件ppt，供参考学习使用

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值