Java Web从如何启动到Servlet&Tomcat

作者: 纸简书生 | 来源:发表于2018-06-11 12:55 被阅读34次

    平时我们在写一般的应用程序的时候,无论如何都会有一个main函数入口。而在进行web开发的时候,从头到尾我们都没有写过一个main函数。最后部署时,打了一个war包,传到web容器下面就可以了。到底这后面发生了什么,带着疑问让我开始吧。

    基础知识

    先了解一下java web应用目录组织结构:

    • WebRoot :Web应用所在目录,一般情况下虚拟目录要配置到此文件夹当中。
    • WEB-INF:此文件夹必须位WebRoot文件夹里面,而且必须以这样的形式去命名,字母都要大写。
    • Web.xml:配置文件,有格式要求,此文件必须以这样的形式去命名,并且必须放置到WEB-INF文件夹中。

    在看看一个浏览器与服务器交互的流程:

    Servlet

    在java web项目中,我们无论是用什么框架,Spring MVC也好,Spring Boot也好,最后都是Servlet在起着决定性的作用。

    Servlet是什么?

    Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

    Servlet在Web应用程序的位置如下图所示:

    image

    Servlet程序是由web容器调用,也就解释了为什么我们所写的web应用程序不需要main函数的原因,它是由web容器根据请然后创建的。

    Servlet主要作用有:

    • 读取客户端(浏览器)发送的数据 。
    • 处理数据并生成结果。这个过程可能需要访问数据库,调用 Web 服务,或者直接计算得出对应的响应。平时的业务逻辑就是在这个部分实现。
    • 发送处理过后的数据给客户端(浏览器)。

    Servlet的运行过程

    web容器收到客户端的访问请求后将进行如下处理:

    1. Web容器首先检查是否已经装载并创建了该Servlet的实例对象。如果是,则直接执行第4步,否则,执行第2步。
    2. 装载并创建该Servlet的一个实例对象。
    3. 调用Servlet实例对象的init()方法。
    4. 创建一个用于封装HTTP请求消息的HttpServletRequest对象和一个代表HTTP响应消息的HttpServletResponse对象,然后调用Servlet的service()方法并将请求和响应对象作为参数传递进去。
    5. WEB应用程序被停止或重新启动之前,Servlet引擎将卸载Servlet,并在卸载之前调用Servlet的destroy()方法。

    具体来讲可以用下面的图说明:

    其时序图可以用下图表示:

    一个Servlet例子

    有了上面的理论基础我们就可以写一个例子加深理解。最终实现一个现实header的效果。

    源码如下:

    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Enumeration;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class DisplayHeaderServlet extends HttpServlet {
        // 处理 GET 方法请求的方法
        public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
        {
            // 设置响应内容类型
            response.setContentType("text/html;charset=UTF-8");
    
            PrintWriter out = response.getWriter();
            String title = "HTTP Header 请求";
            String docType =
                    "<!DOCTYPE html> \n";
            out.println(docType +
                    "<html>\n" +
                    "<head><meta charset=\"utf-8\"><title>" + title + "</title></head>\n"+
                    "<body bgcolor=\"#f0f0f0\">\n" +
                    "<h1 align=\"center\">" + title + "</h1>\n" +
                    "<table width=\"100%\" border=\"1\" align=\"center\">\n" +
                    "<tr bgcolor=\"#949494\">\n" +
                    "<th>Header 名称</th><th>Header 值</th>\n"+
                    "</tr>\n");
    
            Enumeration headerNames = request.getHeaderNames();
    
            while(headerNames.hasMoreElements()) {
                String paramName = (String)headerNames.nextElement();
                out.print("<tr><td>" + paramName + "</td>\n");
                String paramValue = request.getHeader(paramName);
                out.println("<td> " + paramValue + "</td></tr>\n");
            }
            out.println("</table>\n</body></html>");
        }
        // 处理 POST 方法请求的方法
        public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doGet(request, response);
        }
    }
    

    写完之后,还需要将文件便以为class文件,项目部署到tomcat目录下。启动tomcat Web容器访问对应路径即可。

    在web.xml中配置一下加载的Servlet

        <servlet>
            <!-- servlet名,一般写成类名,并不一定严格是类名 -->
            <servlet-name>DisplayHeaderServlet</servlet-name>
            <!-- 所在的包 -->
            <servlet-class>com.xxx.xxx.DisplayHeaderServlet</servlet-class>
        </servlet>
    
        <servlet-mapping>
            <!-- 与上面的servlet-name相对应-->
            <servlet-name>DisplayHeaderServlet</servlet-name>
            <!-- 访问的网址 -->
            <url-pattern>/TomcatTest/DisplayHeaderServlet</url-pattern>
        </servlet-mapping>
    

    Servlet需要注意

    Servlet访问URL映射配置

    由于客户端是通过URL地址访问web服务器中的资源,所以Servlet程序若想被外界访问,必须把servlet程序映射到一个URL地址上。

    这个工作在web.xml文件中使用<servlet>元素和<servlet-mapping>元素完成。<servlet>元素用于注册Servlet,它包含有两个主要的子元素:<servlet-name><servlet-class>,分别用于设置Servlet的注册名称和Servlet的完整类名。

    一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径,它包含有两个子元素:<servlet-name><url-pattern>,分别用于指定Servlet的注册名称和Servlet的对外访问路径。

    • 同一个Servlet可以被映射到多个URL上,即多个<servlet-mapping>元素的<servlet-name>子元素的设置值可以是同一个Servlet的注册名。
    • 同一个Url不能对应多个Servlet。否则会报错Caused by: java.lang.IllegalArgumentException: The servlets named [xxx] and [xxx] are both mapped to the url-pattern xxx

    Servlet访问URL使用*通配符映射

    在Servlet映射到的URL中也可以使用*通配符,但是只能有两种固定的格式:一种格式是"*.扩展名",另一种格式是以正斜杠(/)开头并以"/*"结尾

    但是如果存在了冲突,比如都有*。规则又是怎样的呢?

    请求Url Url1 Url2 规则
    /abc/a.html /abc/* /* Servlet引擎将调用/abc/*
    /abc /abc/* /abc Servlet引擎将调用/abc
    /abc/a.do /abc/* *.do Servlet引擎将调用/abc/*
    /a.do /* *.do Servlet引擎将调用/*
    /xxx/yyy/a.do /* *.do Servlet引擎将调用/*

    匹配的原则就是"谁长得更像就找谁" 。但是当请求url完全匹配的时候就走完全匹配的rul。如上面的第二条。

    Servlet与普通Java类的区别

    Servlet是一个供其他Java程序(Servlet引擎,比如tomcat web容器)调用的Java类,它不能独立运行,它的运行完全由Servlet引擎来控制和调度。这也是开发Web项目没有些main方法的原因。

    针对客户端的多次Servlet请求,通常情况下,服务器只会创建一个Servlet实例对象,也就是说Servlet实例对象一旦创建,它就会驻留在内存中,为后续的其它请求服务,直至web容器退出,servlet实例对象才会销毁

    在Servlet的整个生命周期内,Servlet的init方法只被调用一次。而对一个Servlet的每次访问请求都导致Servlet引擎调用一次servlet的service方法。

    对于每次访问请求,Servlet引擎都会创建一个新的HttpServletRequest请求对象和一个新的HttpServletResponse响应对象,然后将这两个对象作为参数传递给它调用的Servlet的service()方法,service方法再根据请求方式分别调用doXXX方法。

    如果在<servlet>元素中配置了一个<load-on-startup>元素,那么WEB应用程序在启动时,就会装载并创建Servlet的实例对象、以及调用Servlet实例对象的init()方法。

        <servlet>
            <servlet-name>invoker</servlet-name>
            <servlet-class>
                org.apache.catalina.servlets.InvokerServlet
            </servlet-class>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
    

    可以用于为web应用写一个InitServlet,这个servlet配置为启动时装载,为整个web应用创建必要的数据库表和数据。很多第三方框架也需要在应用一加载就实例化Serlvet,比如SpringMVC中的org.springframework.web.servlet.DispatcherServlet

    <!-- springMVC的核心控制器 -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:springMVC-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    

    缺省Servlet

    如果某个Servlet的映射路径仅仅为一个正斜杠(/),那么这个Servlet就成为当前Web应用程序的缺省Servlet。

    凡是在web.xml文件中找不到匹配的<servlet-mapping>元素的URL,它们的访问请求都将交给缺省Servlet处理,也就是说,缺省Servlet用于处理所有其他Servlet都不处理的访问请求。

    比如在tomcat中\conf\web.xml文件中,注册了一个名称为org.apache.catalina.servlets.DefaultServlet的Servlet,并将这个Servlet设置为了缺省Servlet。

        <servlet>
            <servlet-name>default</servlet-name>
            <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
            <init-param>
                <param-name>debug</param-name>
                <param-value>0</param-value>
            </init-param>
            <init-param>
                <param-name>listings</param-name>
                <param-value>false</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
     <!-- The mapping for the default servlet -->
        <servlet-mapping>
            <servlet-name>default</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    

    当访问Tomcat服务器中的某个静态HTML文件和图片时,实际上是在访问这个缺省Servlet。

    Servlet的线程安全问题

    当多个客户端并发访问同一个Servlet时,web服务器会为每一个客户端的访问请求创建一个线程,并在这个线程上调用Servlet的service方法,因此service方法内如果访问了同一个资源的话,就有可能引发线程安全问题

    所有在Servlet中尽量避免使用实例变量 ,最好使用局部变量。

    Servlet如何处理多个请求访问

    Servlet容器默认是采用单实例多线程的方式处理多个请求的:

    • 当web服务器启动的时候(或客户端发送请求到服务器时),Servlet就被加载并实例化(只存在一个Servlet实例)
    • 容器初始化化Servlet主要就是读取配置文件(例如tomcat,可以通过servlet.xml的<Connector>设置线程池中线程数目,初始化线程池通过web.xml,初始化每个参数值等等。
    • 当请求到达时,Servlet容器通过调度线程(Dispatchaer Thread) 调度它管理下线程池中等待执行的线程(Worker Thread)给请求者。
    • 线程执行Servlet的service方法。
    • 请求结束,放回线程池,等待被调用;

    从上面可以看出(好处):

    1. Servlet单实例,减少了产生servlet的开销;
    2. 通过线程池来响应多个请求,提高了请求的响应时间;
    3. Servlet容器并不关心到达的Servlet请求访问的是否是同一个Servlet还是另一个Servlet,直接分配给它一个新的线程。
    4. 如果是同一个Servlet的多个请求,那么Servlet的service方法将在多线程中并发的执行;
    5. 每一个请求由ServletRequest对象来接受请求,由ServletResponse对象来响应该请求;

    Servlet相关对象

    ServletConfig

    上面讲了可以设置Servlet对应的url,那么如何需要配置Serlvet初始化参数怎么办,这就需要用到ServletConfig。在Servlet的配置文件web.xml中,可以使用一个或多个<init-param>标签为servlet配置一些初始化参数。

    <servlet>
        <servlet-name>ServletConfigDemo1</servlet-name>
        <servlet-class>com.xxx.xxx.xxx</servlet-class>
        <!--配置ServletConfig的初始化参数 -->
        <init-param>
            <param-name>name</param-name>
            <param-value>xxx</param-value>
        </init-param>
         <init-param>
            <param-name>password</param-name>
            <param-value>123</param-value>
        </init-param>
        <init-param>
            <param-name>charset</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </servlet>
    

    当servlet配置了初始化参数后,web容器在创建servlet实例对象时,会自动将这些初始化参数封装到ServletConfig对象中,并在调用servlet的init方法时,将ServletConfig对象传递给servlet。进而,我们通过ServletConfig对象就可以得到当前servlet的初始化参数信息。

    获取方式如下:

        /**
         * 定义ServletConfig对象来接收配置的初始化参数
         */
        private ServletConfig config;
        
        /**
         * 当servlet配置了初始化参数后,web容器在创建servlet实例对象时,
         * 会自动将这些初始化参数封装到ServletConfig对象中,并在调用servlet的init方法时,
         * 将ServletConfig对象传递给servlet。进而,程序员通过ServletConfig对象就可以
         * 得到当前servlet的初始化参数信息。
         */
        @Override
        public void init(ServletConfig config) throws ServletException {
            this.config = config;
        }
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            //获取在web.xml中配置的初始化参数
            //获取指定的初始化参数
            String paramVal = this.config.getInitParameter("name");
            response.getWriter().print(paramVal);
            
            response.getWriter().print("<hr/>");
            //获取所有的初始化参数
            Enumeration<String> e = config.getInitParameterNames();
            while(e.hasMoreElements()){
                String name = e.nextElement();
                String value = config.getInitParameter(name);
                response.getWriter().print(name + "=" + value + "<br/>");
            }
        }
    

    比如在使用SpringMVC的时候,在web.xml就使用到了ServletConfig

        <servlet>
            <servlet-name>SpringMVC</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--配置ServletConfig的初始化参数 -->
            <init-param>
                <description>SpringMVC</description>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:spring/spring-mvc.xml</param-value>
            </init-param>
            <!--web容器一旦加载就会创建这个servlet,并且会调用init方法-->
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>SpringMVC</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    

    ServletContext

    对于ServletContext需要我们注意一下几点:

    • WEB容器在启动时,它会为每个WEB应用程序都创建一个对应的ServletContext对象,它代表当前web应用。
    • ServletConfig对象中维护了ServletContext对象的引用,开发人员在编写servlet时,可以通过ServletConfig.getServletContext方法获得ServletContext对象。
    • 由于一个WEB应用中的所有Servlet共享同一个ServletContext对象,因此Servlet对象之间可以通过ServletContext对象来实现通讯。ServletContext对象通常也被称之为context域对象。

    类似于ServletContext(应用上下文)这种设计思想,很多地方都有类似的应用。比如iOS中的画图CGContext 。

    来一个数据共享的例子:

    存储数据:

    public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            String data = "data";
            /**
             * ServletConfig对象中维护了ServletContext对象的引用,开发人员在编写servlet时,
             * 可以通过ServletConfig.getServletContext方法获得ServletContext对象。
             */
             //获得ServletContext对象
            ServletContext context = this.getServletConfig().getServletContext();
             //将data存储到ServletContext对象中
             //将data存储到ServletContext对象中
            context.setAttribute("data", data);  
        }
    

    读取数据:

     public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            ServletContext context = this.getServletContext();\
            //从ServletContext对象中取出数据
            String data = (String) context.getAttribute("data");
            response.getWriter().print("data="+data);
        }
    

    更多的情况下是通过web.xml中读取初始化参数。如下:

        <!-- 配置WEB应用的初始化参数 -->
        <context-param>
            <param-name>url</param-name>
            <param-value>xxx.xxx.xxxx</param-value>
        </context-param>
    

    读取web.xml中的初始化参数

    public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
    
            ServletContext context = this.getServletContext();
            //获取整个web站点的初始化参数
            String contextInitParam = context.getInitParameter("url");
            response.getWriter().print(contextInitParam);
        }
    

    除了读取web.xml中的初始化参数,还可以通过ServletContext读取对象文件。比如常见在项目中使用的xxx.properties文件。很多第三方也是用的这种方式来读取对应的配置文件

     /**
         * 读取src目录下的com.xxx.xxx包中的xxx.properties配置文件
         * @param response
         * @throws IOException
         */
        private void readPropCfgFile2(HttpServletResponse response)
                throws IOException {
            InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/xxx/xxx/xxx.properties");
            Properties prop = new Properties();
            prop.load(in);
            String driver = prop.getProperty("driver");
            String url = prop.getProperty("url");
            String username = prop.getProperty("username");
            String password = prop.getProperty("password");
            response.getWriter().println("读取src目录下的com.xxx.xxx包中的xxx.properties配置文件:");
            response.getWriter().println(
                    MessageFormat.format(
                            "driver={0},url={1},username={2},password={3}", 
                            driver,url, username, password));
        }
    

    除了通过ServletContext读取资源文件,还可以通过类装载器读取资源文件。也有很多第三方是通过这样的方式读取资源文件

       /**
         * 读取类路径下的资源文件
         * @param response
         * @throws IOException
         */
        private void test1(HttpServletResponse response) throws IOException {
            //获取到装载当前类的类装载器
            ClassLoader loader = ServletContextDemo7.class.getClassLoader();
            //用类装载器读取src目录下的db1.properties配置文件
            InputStream in = loader.getResourceAsStream("db1.properties");
            Properties prop = new Properties();
            prop.load(in);
            String driver = prop.getProperty("driver");
            String url = prop.getProperty("url");
            String username = prop.getProperty("username");
            String password = prop.getProperty("password");
            response.getWriter().println("用类装载器读取src目录下的db1.properties配置文件:");
            response.getWriter().println(
                    MessageFormat.format(
                            "driver={0},url={1},username={2},password={3}", 
                            driver,url, username, password));
        }
    

    Web容器

    上一篇讲了Servlet,提到Servlet由容器调用。拿么Web容器是干嘛的呢。

    比较权威的解释:

    web容器是一种服务程序,在服务器一个端口就有一个提供相应服务的程序,而这个程序就是处理从客户端发出的请求,如JAVA中的Tomcat容器,ASP的IIS或PWS都是这样的容器。比如tomcat容器,它提供的接口严格遵守 J2EE 规范中的 WEB APPLICATION 标准。我们把遵守该标准的 WEB 服务器就叫做 J2EE 中的 WEB 容器。 这套标准就是当有客户端请求,自动调用对应的Servlet的标准

    为了加强理解这里再次说明一下:

    servlet没有main方法,那我们如何启动一个servlet,如何结束一个servlet,如何寻找一个servlet等等,都受控于另一个java应用,这个应用我们就称之为web容器。

    比如tomcat就是这样一个容器。如果web服务器应用得到一个指向某个servlet的请求,此时服务器不是把servlet交给servlet本身,而是交给部署该servlet的容器。要有容器向servlet提供http请求和响应,而且要由容器调用servlet的方法,如doPost或者doGet。

    接下来就以Tomcat为例子

    Tomcat

    Tomcat是Apache 软件基金会(Apache Software Foundation)的Jakarta 项目中的一个核心项目,由Apache、Sun 和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持,最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现,Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定,而且免费,因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可,成为目前比较流行的Web 应用服务器。

    体系结构

    • Tomcat服务器的启动是基于一个server.xml文件的,Tomcat启动的时候首先会启动一个Server,Server里面就会启动Service,Service里面就会启动多个Connector(连接器)。
    • 每一个Connector(连接器)都在等待客户机的连接,当有用户使用浏览器去访问服务器上面的web资源时,首先是连接到Connector(连接器),Connector(连接器)是不处理用户的请求的,而是将用户的请求交给一个Engine(引擎)去处理。
    • Engine(引擎)接收到请求后就会解析用户想要访问的Host,然后将请求交给相应的Host。
    • Host收到请求后就会解析出用户想要访问这个Host下面的哪一个Web应用,一个web应用对应一个Context。

    一个简单的配置例子,对照着上面的体系结构来看

    <?xml version='1.0' encoding='utf-8'?>
    <Server port="8005" shutdown="SHUTDOWN">
      <Service name="Catalina">
        <Connector port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
                   maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
                   clientAuth="false" sslProtocol="TLS" 
                   keystoreFile="conf/.keystore" keystorePass="123456"/>
        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
        <Engine name="Catalina" defaultHost="localhost">
    
          <Host name="localhost"  appBase="webapps"
                unpackWARs="true" autoDeploy="true">
            <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
                   prefix="localhost_access_log." suffix=".txt"
                   pattern="%h %l %u %t &quot;%r&quot; %s %b" />
          </Host>
          <!-- host对应的根目录 --> 
          <Host name="www.xxx.xxx" appBase="F:\JavaWebApps">
            <!-- 具体context对应的目录 --> 
            <Context path="" docBase="F:\JavaWebApps\xxxx"/>
          </Host>
    
        </Engine>
      </Service>
    </Server>
    

    Tomcat web.xml

    应用服务器启动时web.xml加载过程,至于这些节点在xml文件中的前后顺序没有关系,不过有些应用服务器,比如websphere就严格要求web.xml的节点顺序,否则部署不成功,所以还是最好按照web.xml标准格式写 :

    具体的配置和加载顺序:content-param --> listener --> filter --> servlet

    结合上面所讲的ServletConfig及ServletContext。

    1. 启动WEB项目的时候,应用服务器会去读它的配置文件web.xml.读两个节点:<context-param></context-param><listener></listener>
    2. 紧接着,容器创建一个ServletContext(上下文),这个WEB项目所有部分都将共享这个上下文。
    3. 容器将<context-param></context-param>转化为键值对,并交给ServletContext。
    4. 容器创建<listener></listener>中的类实例,即创建监听。
    5. 在监听中会有contextInitialized(ServletContextEvent args)初始化方法,在这个方法中获得:ServletContext = ServletContextEvent.getServletContext(); context-param的值 = ServletContext.getInitParameter("context-param的键");
    6. 得到这个context-param的值之后,你就可以做一些操作了.注意,这个时候你的WEB项目还没有完全启动完成,这个动作会比所有的Servlet都要早。换句话说,这个时候,你对<context-param>中的键值做的操作,将在你的WEB项目完全启动之前被执行.如果想在项目启动之前就打开数据库,那么这里就可以在<context-param>中设置数据库的连接方式,在监听类中初始化数据库的连接,这个监听是自己写的一个类,除了初始化方法,它还有销毁方法.用于关闭应用前释放资源.比如说数据库连接的关闭。

    顺序

    以 filter 为例,web.xml 中当然可以定义多个 filter,与 filter 相关的一个配置节是 filter-mapping,这里一定要注意,对于拥有相同 filter-name 的 filter 和 filter-mapping 配置节而言,filter-mapping 必须出现在 filter 之后,否则当解析到 filter-mapping 时,它所对应的 filter-name 还未定义

    web 容器启动时初始化每个 filter 时,是按照 filter 配置节出现的顺序来初始化的,当请求资源匹配多个 filter-mapping 时,filter 拦截资源是按照 filter-mapping 配置节出现的顺序来依次调用 doFilter() 方法的。 servlet 同 filter 类似!

    比如filter 需要用到 bean ,但加载顺序是: 先加载filter 后加载spring,则filter中初始化操作中的bean为null;所以,如果过滤器中要使用到 bean,可以将spring 的加载 改成 Listener的方式

    <listener>
    
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    
    </listener>
    
    

    节点详解

    web-app

    根节点

    <web-app></web-app>
    

    context-param

    用来设定web站台的环境参数。

    它包含两个子元素:

    • <param-name></param-name> 用来指定参数的名称
    • <param-value></param-value> 用来设定参数值

    在此设定的参数,可以在servlet中用 getServletContext().getInitParameter("my_param")来取得。

    例子:

     <context-param>
    
      <param-name>log4jConfigLocation</param-name>
    
      <param-value>classpath*:/log4j.properties</param-value>
    
     </context-param>
    
    

    listener

    用来设定Listener接口,它的主要子元素为:

    • <listener-class></listener-class> 定义Listener的类名称

    例子:

    <listener>
    
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    
     </listener>
    
    

    filter

    是用来声明filter的相关设定

    • <filter-name></filter-name> 这当然就是指定filter的名字
    • <filter-class></filter-class> 这是用来定义filter的类的名称
    • <init-param></init-param> 用来定义参数,它有两个子元素:
    • <param-name></param-name> 用来指定参数的名称
    • <param-value></param-value> 用来设定参数值

    例子:

    <filter>
    
      <filter-name>encodingFilter</filter-name>
    
      <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    
      <init-param>
    
       <param-name>encoding</param-name>
    
       <param-value>GBK</param-value>
    
      </init-param>
    
      <init-param>
    
       <param-name>forceEncoding</param-name>
    
       <param-value>true</param-value>
    
      </init-param>
    
     </filter>
    

    servlet

    来声明一个servlet的数据,主要有以下子元素:

    • <servlet-name></servlet-name> 指定servlet的名称
    • <servlet-class></servlet-class> 指定servlet的类名称
    • <jsp-file></jsp-file> 指定web站台中的某个JSP网页的完整路径
    • <init-param></init-param> 用来定义参数,和前面的<init-param>差不多

    同样,与<servlet></servlet>一起使用的是<servlet-mapping></servlet-mapping> 用来定义servlet所对应的URL,包含两个子元素:<servlet-name></servlet-name> 指定servlet的名称<url-pattern></url-pattern> 指定servlet所对应的URL

     <servlet>
    
      <servlet-name>DemoServlet</servlet-name>
    
      <servlet-class>com.test.DemoServlet</servlet-class>
    
     </servlet>
    
     <servlet-mapping>
    
      <servlet-name>DemoServlet</servlet-name>
    
      <url-pattern>/demoServlet</url-pattern>
    
     </servlet-mapping>
    
    

    description

    是对站台的描述

    例子:

    <description>传道、授业、解惑</description> 
    

    display-name

    定义站台的名称
    例子:

    <display-name>我的站点</display-name>
    

    icon

    icon元素包含small-icon和large-icon两个子元素.用来指定web站台中小图标和大图标的路径.
    <small-icon>/路径/smallicon.gif</small-icon>

    small-icon元素应指向web站台中某个小图标的路径,大小为16 X 16 pixel,但是图象文件必须为GIF或JPEG格式,扩展名必须为:.gif或.jpg.

    <large-icon>/路径/largeicon-jpg</large-icon>
    large-icon元素应指向web站台中某个大图表路径,大小为32 X 32 pixel,但是图象文件必须为GIF或JPEG的格式,扩展名必须为; gif或jpg.
    例子:

    <icon> 
    
     <small-icon>/images/small.gif</small-icon> 
    
     <large-icon>/images/large.gir</large-icon> 
    
    </icon>
    

    distributable

    是指定该站台是否可分布式处理

    session-config

    用来定义web站台中的session参数

    包含一个子元素:
    <session-timeout></session-timeout> 用来定义这个web站台所有session的有效期限,单位为 分钟

    mime-mapping

    定义某一个扩展名和某一个MIME Type做对应该
    包含两个子元素:

    • <extension></extension> 扩展名的名称
    • <mime-type></mime-type> MIME格式

    例子:

     <mime-mapping>
    
      <extension>doc</extension>  
    
      <mime-type>application/vnd.ms-word</mime-type>
    
     </mime-mapping>    
    
     <mime-mapping>
    
      <extension>xls</extension>
    
      <mime-type>application/vnd.ms-excel</mime-type>
    
     </mime-mapping>
    
    

    error-page

    例子

    <error-page> <error-page>
    
         <error-code>500</error-code>
    
         <location>/message.jsp</location>
    
     </error-page>
    
     <error-page>
    
         <error-code>400</error-code>
    
         <location>/message.jsp</location>
    
     </error-page>
    
     <error-page>
    
         <error-code>403</error-code>
    
         <location>/message.jsp</location>
    
     </error-page>
    
     <error-page>
    
         <error-code>404</error-code>
    
         <location>/message.jsp</location>
    
     </error-page>
    
     <error-page>
    
         <error-code>502</error-code>
    
         <location>/index.jsp</location>
    
     </error-page>
    
    

    jsp-config

    例子

    <jsp-config> 
    
     <taglib>
    
     <taglib-uri>/struts-tags</taglib-uri>
    
     <taglib-location>/WEB-INF/struts-tags.tld</taglib-location>
    
     </taglib>
    
     <taglib>
    
     <taglib-uri>/struts-dojo-tags</taglib-uri>
    
     <taglib-location>/WEB-INF/struts-dojo-tags.tld</taglib-location>
    
     </taglib>
    
     <taglib>
    
     <taglib-uri>/s</taglib-uri>
    
     <taglib-location>/WEB-INF/struts-tags.tld</taglib-location>
    
     </taglib>
    
     </jsp-config>
    
    

    welcome-file-list

     <welcome-file-list>
    
     <welcome-file>index.html</welcome-file>
    
     <welcome-file>index.htm</welcome-file>
    
     <welcome-file>index.jsp</welcome-file>
    
     </welcome-file-list>
    
    

    resource-ref

    定义利用JNDI取得站台可利用的资源
    有五个子元素:

    • <description></description> 资源说明
    • <rec-ref-name></rec-ref-name> 资源名称
    • <res-type></res-type> 资源种类
    • <res-auth></res-auth> 资源经由Application或Container来许可
    • <res-sharing-scope></res-sharing-scope> 资源是否可以共享,有Shareable和Unshareable两个值,默认为Shareable

    比如,配置数据库连接池就可在此配置

     <resource-ref>
    
     <description>JNDI JDBC DataSource of shop</description>
    
     <res-ref-name>jdbc/sample_db</res-ref-name>
    
     <res-type>javax.sql.DataSource</res-type>
    
     <res-auth>Container</res-auth>
    
     </resource-ref>
    
    

    扩展阅读

    Tomcat服务器学习和使用(一)

    JavaWeb学习总结

    相关文章

      网友评论

        本文标题:Java Web从如何启动到Servlet&Tomcat

        本文链接:https://www.haomeiwen.com/subject/zbzceftx.html