精华内容
下载资源
问答
  • JSP中的Servlet及Filter

    2014-08-24 14:07:00
    asp.net中,如果开发人员想自己处理http请求...java的web开发中,也有类似的处理机制,与HttpHandler应对的是HttpServlet,与HttpModule对应的则是Filter。 一、HttpServlet 先看一个简单的示例: 1 packag...

    asp.net中,如果开发人员想自己处理http请求响应,可以利用HttpHandler来满足这一要求;类似的,如果要拦截所有http请求,可以使用HttpMoudle。java的web开发中,也有类似的处理机制,与HttpHandler应对的是HttpServlet,与HttpModule对应的则是Filter。

    一、HttpServlet

    先看一个简单的示例:

     1 package com.cnblogs.yjmyzz.servlet;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.ServletException;
     6 import javax.servlet.http.HttpServlet;
     7 import javax.servlet.http.HttpServletRequest;
     8 import javax.servlet.http.HttpServletResponse;
     9 
    10 public class SampleServlet extends HttpServlet {
    11 
    12     private static final long serialVersionUID = 7065409287377444221L;
    13 
    14     public SampleServlet(){
    15         System.out.println("SampleServlet is initialized!");
    16     }
    17     
    18     protected void doGet(HttpServletRequest request,
    19             HttpServletResponse response) throws ServletException, IOException {
    20 
    21         response.getWriter().append("<h1>SampleServlet.doGet() is called!</h1>");
    22 
    23     }
    24 
    25     protected void doPost(HttpServletRequest request,
    26             HttpServletResponse response) throws ServletException, IOException {
    27 
    28         response.getWriter()
    29                 .append("<h1>SampleServlet.doPost() is called!</h1>");
    30 
    31     }
    32 
    33 }
    View Code

    在HttpServlet中,程序员得自己控制所有要在页面上输出的内容,类似ASP.NET HttpHandler中Response.Write(...)一样。

    自定义的Servlet必须在web.xml中注册才能使用,参考下面的配置片段:

    1     <servlet>
    2         <servlet-name>Sample</servlet-name>
    3         <servlet-class>com.cnblogs.yjmyzz.servlet.SampleServlet</servlet-class>
    4         <load-on-startup>1</load-on-startup>
    5     </servlet>
    6     <servlet-mapping>
    7         <servlet-name>Sample</servlet-name>
    8         <url-pattern>/A/*</url-pattern>
    9     </servlet-mapping>
    View Code

    第2行与第7行的servlet-name要一致;url-pattern表示该Servlet要拦截的url,如果写成"/*",则表示拦截所有url请求;load-on-startup是可选节点,如果该节点值>0时,webapp一启动就会自动实例化该Servlet,否则将延时到第一次访问被拦截的url时,才会被实例化。

    如果web.xml中同时注册了多个Servlet,且都指定了load-on-startup,将按照load-on-startup节点值从小到大的优先级顺序,依次实例化所有注册的Servlet。

    如果多个Servlet同时拦截了相同的url,则根据它们出现在web.xml中的顺序,仅最后出现的Servlet具有拦截处理权。

     

    二、Filter

    还是先来一个最基本的示例

     1 package com.cnblogs.yjmyzz.filter;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.Filter;
     6 import javax.servlet.FilterChain;
     7 import javax.servlet.FilterConfig;
     8 import javax.servlet.ServletException;
     9 import javax.servlet.ServletRequest;
    10 import javax.servlet.ServletResponse;
    11 
    12 public class AnotherFilter implements Filter {
    13 
    14     @Override
    15     public void destroy() {
    16         // TODO Auto-generated method stub
    17 
    18     }
    19 
    20     @Override
    21     public void doFilter(ServletRequest reqeust, ServletResponse response,
    22             FilterChain chain) throws IOException, ServletException {
    23         response.getWriter().append("<h1>AnotherFilter.doFilter is called!</h1>");
    24         chain.doFilter(reqeust, response);
    25     }
    26 
    27     @Override
    28     public void init(FilterConfig arg0) throws ServletException {
    29         // TODO Auto-generated method stub
    30 
    31     }
    32 
    33 }
    View Code

    注意下24行,开发人员自定义的处理完成后,最后记得调用chain.doFilter(reqeust, response),因为每一次http请求的完整处理通常会有很多个Filter按顺序协作完成,这些Filter形成一个”链式结构“,这一行的作用,就是当自己的处理完成后,继续交给Filter链中的下一个Filter去处理。

    同样,Filter也必须在web.xml中注册方能使用:

    1     <filter>
    2         <filter-name>Filter2</filter-name>
    3         <filter-class>com.cnblogs.yjmyzz.filter.AnotherFilter</filter-class>
    4     </filter>
    5     <filter-mapping>
    6         <filter-name>Filter2</filter-name>
    7         <url-pattern>/*</url-pattern>
    8     </filter-mapping>
    View Code

     第2行与第6行的filter-name要保持一致;url-pattern为要拦截的url;如果一个web.xml中同时注册多个Filter,所有这些Filter都将起作用,处理的顺序按照在web.xml中出现的顺序,先出现的Filter先处理。

    如果web.xml中同时注册了Servlet、Filter,且拦截的url相同时,Filter先处理,之后才轮到Servlet处理。

     

    三、参数注入

    通常在写Servlet、Filter时,有时候需要从外界获取一些参数,先来看下Filter的参数处理

    a) Filter基本String参数注入

     1 package com.cnblogs.yjmyzz.filter;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.Filter;
     6 import javax.servlet.FilterChain;
     7 import javax.servlet.FilterConfig;
     8 import javax.servlet.ServletException;
     9 import javax.servlet.ServletRequest;
    10 import javax.servlet.ServletResponse;
    11 
    12 public class AnotherFilter implements Filter {
    13     // 定义参数变量
    14     private String someParamter;
    15 
    16     @Override
    17     public void destroy() {
    18 
    19     }
    20 
    21     @Override
    22     public void doFilter(ServletRequest reqeust, ServletResponse response,
    23             FilterChain chain) throws IOException, ServletException {
    24         response.getWriter().append(
    25                 "<h1>AnotherFilter.doFilter is called!" + someParamter
    26                         + "</h1>");
    27         chain.doFilter(reqeust, response);
    28     }
    29 
    30     @Override
    31     public void init(FilterConfig cfg) throws ServletException {
    32         // 取得传入的参数
    33         someParamter = cfg.getInitParameter("someParameter");
    34 
    35     }
    36 
    37 }
    View Code

    代码很简单,在init方法中接收参数即可,这个参数是从哪里传进来的呢?看下面的web.xml配置

    1     <filter>
    2         <filter-name>Filter2</filter-name>
    3         <filter-class>com.cnblogs.yjmyzz.filter.AnotherFilter</filter-class>
    4         <init-param>
    5             <param-name>someParameter</param-name>
    6             <param-value>HelloWorld</param-value>
    7         </init-param>
    8     </filter>
    View Code

    init-param节点就是答案

    b) Filter复杂对象的参数注入

    如果要传的参数是一个复杂对象,上面的方法就不太适合(当然:你可以把对象序列化成json字符串,然后到init中接收,再反序列,理论上也可行,但是比较感觉比较怪。)

    先定义一个参数对象:

     1 package com.cnblogs.yjmyzz.filter;
     2 
     3 public class SampleData {
     4     
     5     private String someField;
     6 
     7     public String getSomeField() {
     8         return someField;
     9     }
    10 
    11     public void setSomeField(String someField) {
    12         this.someField = someField;
    13     }
    14 
    15 }
    View Code

    为了对比,再来一个Filter

     1 package com.cnblogs.yjmyzz.filter;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.Filter;
     6 import javax.servlet.FilterChain;
     7 import javax.servlet.FilterConfig;
     8 import javax.servlet.ServletException;
     9 import javax.servlet.ServletRequest;
    10 import javax.servlet.ServletResponse;
    11 
    12 import org.springframework.beans.factory.annotation.Autowired;
    13 
    14 public class SampleFilter implements Filter {
    15 
    16     @Autowired
    17     SampleData someData;
    18 
    19     @Override
    20     public void destroy() {
    21 
    22     }
    23 
    24     @Override
    25     public void doFilter(ServletRequest reqeust, ServletResponse response,
    26             FilterChain chain) throws IOException, ServletException {
    27         response.getWriter().append(
    28                 "<h1>SampleFilter.doFilter is called!"
    29                         + someData.getSomeField() + "</h1>");
    30         chain.doFilter(reqeust, response);
    31     }
    32 
    33     @Override
    34     public void init(FilterConfig filterConfig) throws ServletException {
    35 
    36     }
    37 
    38     public SampleData getSomeData() {
    39         return someData;
    40     }
    41 
    42     public void setSomeData(SampleData someData) {
    43         this.someData = someData;
    44     }
    45 
    46 }
    View Code

    这里,我们希望SomeFilter在运行时,能动态注入一个SomeData实例。下面是配置部分:

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
     5 
     6     <bean id="someData" class="com.cnblogs.yjmyzz.filter.SampleData">
     7         <property name="someField" value="abc"></property>
     8     </bean>
     9 
    10     <bean id="sampleFilter" class="com.cnblogs.yjmyzz.filter.SampleFilter">
    11         <property name="someData" ref="someData"></property>
    12     </bean>
    13 
    14 </beans>
    View Code

    spring的xml配置中,先定义好SomeFilter的bean,然后是web.xml的Filter配置:

     1     <filter>
     2         <description>Filter1</description>
     3         <display-name>Filter1</display-name>
     4         <filter-name>Filter1</filter-name>
     5         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
     6         <init-param>
     7             <param-name>targetBeanName</param-name>
     8             <param-value>sampleFilter</param-value>
     9         </init-param>
    10     </filter>
    11 
    12     <filter-mapping>
    13         <filter-name>Filter1</filter-name>
    14         <url-pattern>/*</url-pattern>
    15     </filter-mapping>
    View Code

    对比下刚才的Filter配置,有几个变化:

    filter-class 换成了 org.springframework.web.filter.DelegatingFilterProxy

    init-param 节点通过targetBeanName 这个参数名,将sampleFilter bean动态注入

     

    再来看看Servlet的参数注入,spring并没有提供类似DelegatingServletProxy的代理类,所以只能自己动手了,下面是二种常见做法:

    a) 通过init方法,实现Servlet的Spring bean注入

     1 package com.cnblogs.yjmyzz.servlet;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.*;
     6 import javax.servlet.http.*;
     7 import org.springframework.web.context.WebApplicationContext;
     8 import org.springframework.web.context.support.WebApplicationContextUtils;
     9 
    10 import com.cnblogs.yjmyzz.filter.SampleData;
    11 
    12 public class SampleServlet extends HttpServlet {
    13 
    14     private static final long serialVersionUID = 7065409287377444221L;
    15 
    16     SampleData someData;
    17 
    18     public SampleServlet() {
    19         System.out.println("SampleServlet is initialized!");
    20     }
    21 
    22     protected void doGet(HttpServletRequest request,
    23             HttpServletResponse response) throws ServletException, IOException {
    24 
    25         response.getWriter().append(
    26                 "<h1>SampleServlet.doGet() is called!"
    27                         + someData.getSomeField() + "</h1>");
    28 
    29     }
    30 
    31     protected void doPost(HttpServletRequest request,
    32             HttpServletResponse response) throws ServletException, IOException {
    33 
    34         response.getWriter().append(
    35                 "<h1>SampleServlet.doPost() is called!</h1>");
    36 
    37     }
    38 
    39     public void init() throws ServletException {
    40         super.init();
    41         ServletContext servletContext = this.getServletContext();
    42         WebApplicationContext ctx = WebApplicationContextUtils
    43                 .getWebApplicationContext(servletContext);
    44         someData = ctx.getBean("someData", SampleData.class);
    45     }
    46 }
    View Code

    关键在于init方法,通过Spring的WebApplicationContext拿到上下文,然后手动去获取bean实例

    b) 自己实现ServletProxy,实现注入

    先定义ServletProxy代理类:

     1 package com.cnblogs.yjmyzz.servlet;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.*;
     6 import javax.servlet.http.HttpServlet;
     7 
     8 import org.springframework.web.context.WebApplicationContext;
     9 import org.springframework.web.context.support.WebApplicationContextUtils;
    10 
    11 public class HttpServletProxy extends HttpServlet {
    12 
    13     private static final long serialVersionUID = 4358391761577767574L;
    14 
    15     private String targetBean;
    16     private HttpServlet proxy;
    17 
    18     public void service(ServletRequest req, ServletResponse res)
    19             throws ServletException, IOException {
    20         proxy.service(req, res);
    21     }
    22 
    23     public void init() throws ServletException {
    24         this.targetBean = getServletName();
    25         getServletBean();
    26         proxy.init(getServletConfig());
    27     }
    28 
    29     private void getServletBean() {
    30         WebApplicationContext wac = WebApplicationContextUtils
    31                 .getRequiredWebApplicationContext(getServletContext());
    32         this.proxy = (HttpServlet) wac.getBean(targetBean);
    33     }
    34 
    35 }
    View Code

    本质上ServletProxy也是一个Servlet,在init方法中,通过动态获取servletName,利用Spring的WebApplicationContextt得到真正需要的Servlet Bean实例并保存在proxy变量中,最终对http执行处理的(即:调用service方法的),是proxy变量所指向的Servlet Bean实例。

    定义真正需要使用的Servlet

     1 package com.cnblogs.yjmyzz.servlet;
     2 
     3 import java.io.IOException;
     4 
     5 import javax.servlet.ServletException;
     6 import javax.servlet.http.HttpServlet;
     7 import javax.servlet.http.HttpServletRequest;
     8 import javax.servlet.http.HttpServletResponse;
     9 import com.cnblogs.yjmyzz.filter.SampleData;
    10 
    11 public class AnotherServlet extends HttpServlet {
    12 
    13     private static final long serialVersionUID = -3797187540470927379L;
    14 
    15     // 需要注入的Bean
    16     SampleData someData;
    17 
    18     public AnotherServlet() {
    19         System.out.println("AnotherServlet is initialized!");
    20     }
    21 
    22     protected void doGet(HttpServletRequest request,
    23             HttpServletResponse response) throws ServletException, IOException {
    24 
    25         response.getWriter().append(
    26                 "<h1>AnotherServlet.doGet() is called!"
    27                         + someData.getSomeField() + "</h1>");
    28 
    29     }
    30 
    31     protected void doPost(HttpServletRequest request,
    32             HttpServletResponse response) throws ServletException, IOException {
    33 
    34         response.getWriter().append(
    35                 "<h1>AnotherServlet.doPost() is called!</h1>");
    36 
    37     }
    38 
    39     public void setSomeData(SampleData someData) {
    40         this.someData = someData;
    41     }
    42 
    43 }
    View Code

    在spring的beans配置文件中,配置该Servlet Bean

    1     <bean id="someData" class="com.cnblogs.yjmyzz.filter.SampleData">
    2         <property name="someField" value="abc"></property>
    3     </bean>
    4 
    5     <bean id="anotherServlet" class="com.cnblogs.yjmyzz.servlet.AnotherServlet">
    6         <property name="someData" ref="someData"></property>
    7     </bean>
    View Code

    最后是web.xml配置

    1     <servlet>
    2         <servlet-name>anotherServlet</servlet-name>
    3         <servlet-class>com.cnblogs.yjmyzz.servlet.HttpServletProxy</servlet-class>
    4         <load-on-startup>1</load-on-startup>
    5     </servlet>
    6     <servlet-mapping>
    7         <servlet-name>anotherServlet</servlet-name>
    8         <url-pattern>/A/*</url-pattern>
    9     </servlet-mapping>
    View Code

    注:web.xml中的servlet-name节点值,必须于spring beans配置文件中的bean id一致,因为ServletProxy是根据ServletName来查找Bean实例的。

     

    展开全文
  • servlet、过滤器、监听器servlet是Java中WEB请求和响应的容器servlet的运行需要在类似tomcat容器中,一个 Web 应用对应一个 Context 容器,也就是 Servlet 运行时 Servlet 容器tomcat启动逻辑是基于观察者模式...

    servlet、过滤器、监听器
    servlet是Java中WEB请求和响应的容器
    servlet的运行需要在类似tomcat容器中,
    一个 Web 应用对应一个 Context 容器,也就是 Servlet 运行时的 Servlet 容器
    tomcat的启动逻辑是基于观察者模式设计的,所有的容器都会继承Lifecycle接口,
    所有容器的修改和状态的改变都会由它去通知已经注册的观察者(Listener)


    Servlet过滤器是 Servlet 程序的一种特殊用法,
    主要用来完成一些通用的操作,如编码的过滤、判断用户的登录状态。
    Servlet过滤器本身不产生请求和响应,它只提供过滤作用
    这个不要忘了
    在doFilter()方法的最后,使用FilterChain参数的doFilter()方法将请求和响应后传


    Servlet监听器也叫做 listener
    通过它可以监听Web应用的上下文(环境)信息、
    Servlet请求信息、Servlet会话信息,
    并自动根据不同情况,在后台调用相  应的处理程序。
    通过监听器,可以自动激发一些操作,比如监听在线人数



    http://www.ibm.com/developerworks/cn/java/j-lo-servlet/
    http://blog.csdn.net/chuyuqing/article/details/8267832

    转载于:https://www.cnblogs.com/sun-rain/p/5200920.html

    展开全文
  • java Servlet笔记6

    2020-10-09 11:21:01
    HTTP 请求和 HTTP 响应消息格式是类似的,结构如下: 初始状态行 + 回车换行符(回车+换行) 零个或多个标题行+回车换行符 一个空白行,即回车换行符 一个可选消息主体,比如文件、查询数据或查询输出 状态行...

    Servlet HTTP 状态码

    HTTP 请求和 HTTP 响应消息的格式是类似的,结构如下:

    • 初始状态行 + 回车换行符(回车+换行)
    • 零个或多个标题行+回车换行符
    • 一个空白行,即回车换行符
    • 一个可选的消息主体,比如文件、查询数据或查询输出

    状态行包括 HTTP 版本、一个状态码和一个对应于状态码的短消息。

    Web 服务器返回的 HTTP 状态码和相关的信息列表:

    代码 消息 描述
    100 Continue 只有请求的一部分已经被服务器接收,但只要它没有被拒绝,客户端应继续该请求。
    101 Switching Protocols 服务器切换协议。
    200 OK 请求成功。
    201 Created 该请求是完整的,并创建一个新的资源。
    202 Accepted 该请求被接受处理,但是该处理是不完整的。
    203 Non-authoritative Information
    204 No Content
    205 Reset Content
    206 Partial Content
    300 Multiple Choices 链接列表。用户可以选择一个链接,进入到该位置。最多五个地址。
    301 Moved Permanently 所请求的页面已经转移到一个新的 URL。
    302 Found 所请求的页面已经临时转移到一个新的 URL。
    303 See Other 所请求的页面可以在另一个不同的 URL 下被找到。
    304 Not Modified
    305 Use Proxy
    306 Unused 在以前的版本中使用该代码。现在已不再使用它,但代码仍被保留。
    307 Temporary Redirect 所请求的页面已经临时转移到一个新的 URL。
    400 Bad Request 服务器不理解请求。
    401 Unauthorized 所请求的页面需要用户名和密码。
    402 Payment Required 您还不能使用该代码。
    403 Forbidden 禁止访问所请求的页面。
    404 Not Found 服务器无法找到所请求的页面。.
    405 Method Not Allowed 在请求中指定的方法是不允许的。
    406 Not Acceptable 服务器只生成一个不被客户端接受的响应。
    407 Proxy Authentication Required 在请求送达之前,您必须使用代理服务器的验证。
    408 Request Timeout 请求需要的时间比服务器能够等待的时间长,超时。
    409 Conflict 请求因为冲突无法完成。
    410 Gone 所请求的页面不再可用。
    411 Length Required “Content-Length” 未定义。服务器无法处理客户端发送的不带 Content-Length 的请求信息。
    412 Precondition Failed 请求中给出的先决条件被服务器评估为 false。
    413 Request Entity Too Large 服务器不接受该请求,因为请求实体过大。
    414 Request-url Too Long 服务器不接受该请求,因为 URL 太长。当您转换一个 “post” 请求为一个带有长的查询信息的 “get” 请求时发生。
    415 Unsupported Media Type 服务器不接受该请求,因为媒体类型不被支持。
    417 Expectation Failed
    500 Internal Server Error 未完成的请求。服务器遇到了一个意外的情况。
    501 Not Implemented 未完成的请求。服务器不支持所需的功能。
    502 Bad Gateway 未完成的请求。服务器从上游服务器收到无效响应。
    503 Service Unavailable 未完成的请求。服务器暂时超载或死机。
    504 Gateway Timeout 网关超时。
    505 HTTP Version Not Supported 服务器不支持"HTTP协议"版本。

    设置 HTTP 状态代码的方法

    ​ 在 Servlet 程序中设置 HTTP 状态码。这些方法通过 HttpServletResponse 对象可用。

    序号 方法 & 描述
    1 public void setStatus ( int statusCode ) 该方法设置一个任意的状态码。setStatus 方法接受一个 int(状态码)作为参数。如果您的响应包含了一个特殊的状态码和文档,请确保在使用 PrintWriter 实际返回任何内容之前调用 setStatus。
    2 public void sendRedirect(String url) 该方法生成一个 302 响应,连同一个带有新文档 URL 的 Location 头。
    3 public void sendError(int code, String message) 该方法发送一个状态码(通常为 404),连同一个在 HTML 文档内部自动格式化并发送到客户端的短消息。

    HTTP 状态码实例

    @WebServlet("/showError")
    public class showError extends HttpServlet {
    
        //处理GET方法请求的方法
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //设置错误代码和原因
            resp.sendError(407,"测试错误");
        }
    
        //处理POST方法请求的方法
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }
    
    展开全文
  • 拦截了请求,如果不放行,就不会到对应的Servlet 如果放行了,就会到对应的Servlet 如果Servlet有响应,那么还会再次经过Filter再到浏览器 演示单个拦截器 Filter实现类: package com.filter; import java....

    拦截/过滤器 : 拦截请求,对请求和响应做出处理。本质上与servlet类似。

    特点 :

    1. 请求最终是要到Servlet
    2. 拦截了请求,如果不放行,就不会到对应的Servlet
    3. 如果放行了,就会到对应的Servlet
    4. 如果Servlet有响应,那么还会再次经过Filter再到浏览器

    演示单个拦截器

    Filter实现类:

    package com.filter;
    
    import java.io.IOException;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    
    public class MyFilter1 implements Filter{
    
    	public MyFilter1() {
    		System.out.println("MyFilter1 拦截器创建");
    	}
    	
    	public void init(FilterConfig filterConfig) throws ServletException {
    		System.out.println("MyFilter1 拦截器初始化");
    	}
    
    	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    			throws IOException, ServletException {
    		System.out.println("MyFilter1 拦截器 执行拦截");
    		// 放行 : 放行到下一个拦截器,如果这是最后一个,那就放行到对应的Servlet
    		 chain.doFilter(request, response);
    		 System.out.println("放行后");
    	}
    
    	public void destroy() {
    		System.out.println("MyFilter1 拦截器销毁");
    	}
    
    }
    

     web.xml :

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
      <display-name>day41_filter</display-name>
      <welcome-file-list>
        <welcome-file>index.htm</welcome-file>
      </welcome-file-list>
      <!-- 拦截器 -->
      <filter>
      	<filter-name>f1</filter-name>
      	<filter-class>com.zhiyou100.filter.MyFilter1</filter-class>
      </filter>
      <filter-mapping>
      	<filter-name>f1</filter-name>
      	<url-pattern>/f1</url-pattern>
      </filter-mapping>
      <!-- 映射Servlet -->
      <servlet>
      	<servlet-name>s1</servlet-name>
      	<servlet-class>com.zhiyou100.filter.MyServlet</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>s1</servlet-name>
      	<url-pattern>/f1</url-pattern>
      </servlet-mapping>
    </web-app>
    

    Servlet继承类:

    public class MyServlet extends HttpServlet{
    	
    	
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		System.out.println("MyServlet 执行了");
    		resp.sendRedirect("index.jsp");
    	}
    
    }

    多个拦截器

    配置了3个拦截器, MyFilter1  , 2, 3 三个拦截器的名字是f1 f2 f3 ,但是拦截的路径都是/f1

     

    Filter的生命周期

    1 项目启动,拦截器即创建

    2 创建后立即初始化

    3 每次有对应的请求,都会执行拦截

    4 项目卸载或者是服务器宕机就会销毁

    编码格式过滤

    拦截所有请求,到EncodingFilter 拦截器,对请求进行编码格式过滤,后再将请求放行, 后续的所有Servlet就不再需要对编码进行过滤

     

     

    展开全文
  • 过滤器与包装器

    2016-05-20 18:36:00
    Servlet类似,过滤器也有init()和destroy()方法,对应于servletdoGet()/doPost(),过滤器则有一个doFilter()方法。过滤器也需要在DD中声明,过滤器运行顺序也将在DD中声明。 1.过滤器中生命周期  首先要...
  • 一种是通过类似于bridge的方式,现在外层的Web Application中配置一个对应的元素,然后通过对这个元素将外部的访问桥接到OSGi容器内部。在OSGi容器内部,会有一个总控的service,通过这个service来提供Web元素的动态...
  •  (2) Ajax 可以直接和 Servlet 使用,Ajax的URL可以是Servlet 对应的 URL  (3)rest 与servlet 类似,提供请求响应,而 SpringMVC的注解方式,又与Rest 有相似的地方 2. 练习:  (1) 基
  • 上一节中的编译指令是给Servelt引擎看的,而这一节中提到的动作...当然,在转译之后,这些动作指令会变成标准的java代码,保存在对应的Servlet中。JSP主要的动作指令有7个。forward:用于将页面响应转发到另外的html...
  • Spring MVC总结

    2019-08-26 10:51:28
    C 代表 控制器(controller),即负责接收并转发请求,对请求处理之后拿到响应结果,指派要使用的视图(类似于指定Servlet跳转到不同的页面进行展示),将响应结果返回给客户端。对应的组件一般是Servlet SpringMVC...
  • 在系统设计和开发过程中,要充分考虑系统当前和将来可能承受工作量,使系统处理能力和响应时间能够满足信息处理需求。 2、 系统开放性和系统可扩充性:系统在开发过程中,应该充分考虑以后可扩充性。...
  • Response

    2017-09-11 00:06:00
    Response 一、Response的运行过程 ...Tomcat引擎(解析,内部封装request...对应的Web程序的Servlet-------->然后将Response响应放到response缓冲区(类似)------->Tomcat引擎取出Response缓冲区内容---...
  • 同一个公众号可以配置多个@Weixin注解控制器类,其中只需要一个有其他4项配置就可以了,如果多个控制器类配置了其他4个配置项,如果相对应的配置项值不相同,启动阶段会报错。 不同微信公众号是通过@Weixin的value...
  • (4)用户界面具备更短的响应时间:现代GUI框架中大都使用一个事件分发线程(类似于中断响应函数)来替代主事件循环,当用户界面用有事件发生时,在事件线程中将调用对应的事件处理函数(类似于中断处理函数) ...
  • 一文带你搞懂API网关

    2020-12-28 06:45:32
    需要考虑到网关缩容、扩容时修改对应的限流数。 - 分布式。分布式的就需要一个存储节点维护当前接口的调用数,比如redis、sentinel等,这种方式由于涉及到远程调用,会有些性能损耗,另外也...
  • 微信开发框架wechat4j

    2015-11-19 23:49:27
    如果是springmvc则创建对应的controller,如果是struts则创建对应的action类。servlet类示例如下: ```java protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    描述JSP和Servlet的区别、共同点、各自应用范围 2.在Web开发中需要处理HTML标记时,应做什么样处理,要筛选那些字符(< > & “”) 3.在JSP中如何读取客户端请求,如何访问CGI变量,如何确定某个Jsp文件...
  • Struts2属性文件详解

    2010-02-11 03:10:11
    注意: 如果需要使用cos或者pell的文件上传方式,则应该将对应的JAR文件复制到Web应用中.例如,使用cos上传方式,则需要自己下载cos框架的JAR文件,并将该文件放在WEB-INF/lib路径下. struts.multipart.saveDir 该属性...
  • springmybatis

    2015-09-05 06:54:28
    1.Configuration.xml 是 mybatis 用来建立 sessionFactory 用的,里面主要包含了数据库连接相关东西,还有 java 类所对应的别名,比如 <typeAlias alias="User" type="com.yihaomen.mybatis.model.User"/> 这个别名...
  • 当然还包括对应的对象形式Integerv,Boolean等等.DWR中在allow预定义了16个配置项目分别用于所有基本类型的转换.就象这样<convert converter="primitive" match="java.lang.Long"/><convert converter="primitive" ...
  • 这些变量不同于它们普通对应物,因为访问某个变量(通过其 get 或 set 方法)每个线程都有自己局部变量,它独立于变量初始化副本。ThreadLocal 实例通常是类中 private static 字段,它们希望将状态与某一...
  • 堆栈 [stæk] (对应 heap 堆) statement 程序语句; 语句 ['steitmәnt]' n. 陈述,指令 subclass n.子类 ['sʌbklɑ:s]' (supertype 父类) switch (关键字) 选择语句。 n.开关,道岔 [switʃ] synchronized (关键字)...
  • --命名空间,类似包的概念: namespace:绑定一个对应的Dao/Mapper接口--> <mapper namespace="com.sunny.dao.UserDao"> <!-- select元素: 专门用来做查询的SQL -id属性: 唯一标识,用来标识某一条SQL...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
关键字:

响应对应的servlet类似