Ⅰ servlet可以被strutsprepareandexecutefilter拦截吗
这个就抄牵扯到struts2的底层源码了袭
StrutsPrepareAndExecuteFilte 实现了Filter接口
服务器启动调用StrutsPrepareAndExecuteFilte .init()初始化来初始化几个重要的类,比如Dispatcher
当前台有请求发来,StrutsPrepareAndExecuteFilte 的doFilter()被调用
进行request等的封装,找到相应action,执行相应action
struts的拦截器很重要,配置在struts-deafault.xml里有很多拦截器
比如说吧: <interceptor name="params" class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>
这个拦截器就是自动根据前台来的request来封装action属性的拦截器
Ⅱ 用了struts2还能用普通的servlet吗
这是必然的啊...
struts2的filter必须抄映射成/*..
能不能用servlet我也没试...
http://..com/question/77895495.html
我的struts2问题..
没人回答..
郁闷了 ...
IMPORTANT: this filter must be mapped to all requests. Unless you know exactly what you are doing, always map to this URL pattern: /*
这是struts2 DOC文档里的FilterDispatcher的第一句话..请认真阅读文档!
Ⅲ 如何让struts2和servlet的共存
解决方法目前有四种：
方法1：
统一在后面加上.servlet结尾（包括web.xml配置文件中和页面上使用servlet的地方）
方法2：
在struts.xml中的<struts>的节点下面添加struts2处理的请求后缀 常量：
<!--
该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts 2处理。
如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（，）隔开。
-->
<constant name="struts.action.extension" value="action" />
方法3：
在web.xml中修改struts2拦截页面请求的配置：
原：
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
现：
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/user/*</url-pattern>
</filter-mapping>
servlet的请求路径不必改变
方法4：
自定义filter对servlet进行过滤：
##############################################
# 该类是定义了一个过滤器（随便你放在某个包下面），当既用到struts2又用到servlet时，
# 必须用该过滤器对所有的servlet做一次过滤，否则servlet将无法正常运行。
# 同时在web.xml中，在定义struts的核心控制器的过滤器前面添加该过滤器，添加代码如下：
* <filter>
* <filter-name>redisp</filter-name>
* <filter-class>filters.ReDispatcherFilter（该过滤器的类名）</filter-class>
* <init-param>
* <param-name>includeServlets</param-name>
* <param-value>所配置的servlet，注意是那url-pattern</param-value>
* </init-param>
* </filter>
* <filter-mapping>
* <filter-name>redisp</filter-name>
* <url-pattern>/*</url-pattern>
* </filter-mapping>
*该类也可以直接继承StrutsPrepareAndExecuteFilter的
###########################################################
public class ReDispatcherFilter implements Filter {
public void destroy() {
// TODO Auto-generated method stub
}
public void doFilter(ServletRequest req, ServletResponse resp,
FilterChain chain) throws IOException, ServletException
{
HttpServletRequest request = (HttpServletRequest)req;
String target = request.getRequestURI();
target = target.lastIndexOf("?")>0
?target.substring(target.lastIndexOf("/")+1,target.lastIndexOf("?")-target.lastIndexOf("/"))
:target.substring(target.lastIndexOf("/")+1);
System.out.println(target);
if(this.includes.contains(target))
{
RequestDispatcher rdsp = request.getRequestDispatcher(target);
System.out.println("go..............."+rdsp);
rdsp.forward(req, resp);
}
else
chain.doFilter(req, resp);
}
private ArrayList<String> includes = new ArrayList<String>();
public void init(FilterConfig config) throws ServletException {
this.includes.addAll( Arrays.asList(config.getInitParameter("includeServlets").split(",")));
}
}
Ⅳ struts2拦截了servlet的请求 求大神解决
<url-pattern>*.action</url-pattern> 是过滤的制url 关键部位 (结尾)
http://..com/question/481754705.html 这样 的
你是 481754705.html 这样， 过滤器过滤 question481754705.html 结尾
所以 你的过滤器在你所请求中永远不生效 （说白了就是少了个 /）
Ⅳ 什么是serverlet，filter，listener
对一类 url,或所有 url 进行业务处理 对各种 url 之类进行匹配，查找，执行相应操作，与 action 相比较而言，action 只能针对 某一特定的 url 进行匹配，进行操作 如: <form action = "update.action"> action 对应的 url 是固定的，对于 struts1.x 可能一个 action 只有一个 url 对于 struts2.0，一个 action 可能有多个 url,看它实现的方法数量，不过这些 url 在提交 之前都是已经的，固定的。而上面四种可以对任意 url 进行操作，如 <url-pattern>*.action</url-pattern> 区别：1,servlet 流程是短的，url 传来之后，就对其进行处理，之后返回或转向到某一自 己指定的页面。它主要用来在 业务处理之前进行控制. 2,filter 流程是线性的， url 传来之后，检查之后，可保持原来的流程继续向下执行， 被下一个 filter, servlet 接收等，而 servlet 处理之后，不会继续向下传递。filter 功能可用来保持流程继续按照原来的方式进行下去，或者主导流程，而 servlet 的功能主要用 来主导流程。 filter 可用来进行字符编码的过滤，检测用户是否登陆的过滤，禁止页面缓存等 3, servlet,filter 都是针对 url 之类的， listener 是针对对象的操作的， session 而 如 的创建，session.setAttribute 的发生，在这样的事件发生时做一些事情。 可用来进行：Spring 整合 Struts,为 Struts 的 action 注入属性，web 应用定时任 务的实现，在线人数的统计等 4，interceptor 拦截器，类似于 filter,不过在 struts.xml 中配置，不是在 web.xml, 并且不是针对 URL 的，而是针对 action,当页面提交 action 时，进行过滤操作，相当于 struts1.x 提供的 plug-in 机制，可以看作，前者是 struts1.x 自带的 filter,而 interceptor 是 struts2 提供的 filter. 与 filter 不同点：（1）不在 web.xml 中配置，而是在 struts.xml 中完成配置，与 action 在一起 ( 2 interceptor 来在接收之前做事 一，servlet 1， 在 web.xml 中配置 Servlet <servlet> <servlet-name>AutoServlet</servlet-name> <servlet-class> com.servlet.AutoServlet </servlet-class> </servlet> <servlet-mapping> <servlet-name>AutoServlet</servlet-name> <url-pattern>/AutoServlet</url-pattern> </servlet-mapping> 2，定义 AutoServlet,继承 HttpServlet,实现方法 doGet, doPost ) 可由 action 自己指定用哪个 3, 应用： （1）Struts1.x 就是一个 Servlet, 它会在 doGet 方法中读取配置文件 struts-config.xml 进行 action 的匹配，进行 （2）验证码生成（也可用 action 来做） 业务处理 二，filter 1, web.xml 配置 <filter> <filter-name>checkUrl</filter-name> <filter-class>com.lvjian.filter.CheckUrl</filter-class> <init-param> <param-name>name</param-name> <param-value>asong</param-value> //初始化传参，得到时在 filter 的 init 方法中用 filterConfig.getInitParameter( "name" ) </init-param> </filter> <filter-mapping> <filter-name>checkUrl</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> 2, 继承 javax.servlet.Filter,实现 doFilter(HttpServletRequest request, HttpServletResponse response FilterChain filterChain) 等方法 HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) res; //获取用户请求的 URI String request_uri = request.getRequestURI(); //获取 web 应用程序的上下文路径 String contextPath = request.getContextPath(); //去除上下文路径，得到剩余部分的路径 String uri = request_uri.substring(contextPath.length()); //创建会话 session HttpSession session = request.getSession(true); //保持原有流程不变 filterChain.doFilter( servletRequest , servletResponse ); 3,应用：（1）Struts2.0 (2) 进行字符编码的过滤，检测用户是否登陆的过滤等 （3）禁止页面缓存，原理就是对各个请求的 url 令其为空,在 doFilter 加入： request.setCharacterEncoding("GB2312");//设置编码 ((HttpServletResponse)response).setHeader("Pragma" ,"No-cache"); ((HttpServletResponse)response).setHeader("Cache-C ontrol","no-cache"); ((HttpServletResponse)response).setHeader("Expires ","0");//禁止缓存 三，listener 1， 在 web.xml 中配置 <listener> <listener-class>demo.listener.MyContextLoader</listener-class> </listener> //这样服务器就会在启动时创建 MyContextLoader 的一个实例，并开始监听 servlet,session 的操作 2, 实现 常用的 listener 有： （1） ServletContextListener 监听 ServletContext。 当创建 ServletContext 时，激 发 contextInitialized(ServletContextEvent sce)方法； 当销毁 ServletContext 时， 激发 contextDestroyed(ServletContextEvent sce)方法。 （2） 监听对 ServletContext 属性的操作，比 如增加、删除、修改属性。 （3）HttpSessionListener 监听 HttpSession 的操作。 当创建一个 Session 时，激发 session Created(HttpSessionEvent se) 方法； 当销毁一个 Session 时， 激发 sessionDestroyed (HttpSessionEvent se) 方法。 （4）HttpSessionAttributeListener 监听 HttpSession 中的属性的操作。 当在 Session 增加一个属性时，激 发 attributeAdded(HttpSessionBindingEvent se) 方法； 当在 Session 删除一个属性时，激发 attributeRemoved(HttpSessionBindingEventse)方法； 当在 Session 属性被重新设置时，激发 attributeReplaced(HttpSessionBindingEvent se) 方法。 四，interceptor 1, 在 struts.xml 中配置 创建一个 strus.xml 的子配置文件 struts-l99-default.xml，它继承与 struts2 的 struts-default，此配置文件是其他子配置文件的父类，只要是继承与该文件的配置文件所 声明的路径都会被它过滤 . 方法 1. 普通配置法 <struts> <package name="struts2" extends="struts-default"> <interceptors> <interceptor name="myInterceptor" class="e.hust.interceptor.MyInterceptor"></interceptor> </interceptors> <action name="register" class="e.hust.action.RegisterAction"> <result name="input">/register.jsp</result> <result>/result.jsp</result> <!-- 在自定义 interceptor 并将其 ref 时, 系统会覆盖掉默认的 interceptor-stack(defaultStack), 为了保证系统默认的 defaultStack 不受影 响, 我们需要显式的将其引入 --> <!-- 注意两个 interceptor-ref 的顺序, 顺序不同, 执行效果也不同: 先配置的先 执行/后配置的先退出(先进后出) --> <interceptor-ref name="defaultStack"></interceptor-ref> <interceptor-ref name="myInterceptor"></interceptor-ref> </action> </package> </struts> 方法 2. 配置拦截器栈(即将多个 interceptor 串联的一种元素)。然后在<action>中引入 该拦截器栈就可以了。 执行顺序为先配置的先执行 这样做的原因是：多个 action 有相同的多个 interceptor 时，如一般自己写一个，系统 默认的有一个，要注入两个， 对多个 action 都写这两个，不利于修改，可以写成一个链，只需引用此链即可。 (1)拦截目标对象(被代理对象)，这里目标对象就是 action；(2)拦截器(一个类，动态的将 某些方法插入到目标对象的某方法的 before、after)；(3)对目标对象生成的(动态)代理对 象(代理对象内部方法综合了目标对象方法+拦截器方法)。程序最终执行的是目标对象的代理， 而这个代理已经插入了 interceptor。拦截器作用：拦截 action。interceptor 相当于一 个入口和出口， 通过 interceptor 进入 action， 执行完 action 的代码再通过 interceptor 出去。针对"struts2 -- interceptor(Interceptor 怎么写)"这篇文章的 MyInterceptor.class 和 MyInterceptor2.class。根据下面的配置文件执行程 序 <struts> <package name="struts2" extends="struts-default"> <struts> <package name="struts2" extends="struts-default"> <interceptors> <interceptor name="myInterceptor" class="e.hust.interceptor.MyInterceptor"></interceptor> <interceptor-stack name="myInterceptorStack"> <interceptor-ref name="myInterceptor"></interceptor-ref> <interceptor-ref name="defaultStack"></interceptor-ref> </interceptor-stack> </interceptors> <action name="register" class="e.hust.action.RegisterAction"> <result name="input">/register.jsp</result> <result>/result.jsp</result> <interceptor-ref name="myInterceptorStack"></interceptor-ref> </action> </package> </struts> 方法 3. 修改默认拦截器，将自定义的拦截器栈定义为 struts2 的默认拦截器。 <struts> <package name="struts2" extends="struts-default"> <interceptors> <interceptor name="myInterceptor" class="e.hust.interceptor.MyInterceptor"></interceptor> <interceptor-stack name="myInterceptorStack"> <interceptor-ref name="myInterceptor"></interceptor-ref> <interceptor-ref name="defaultStack"></interceptor-ref> </interceptor-stack> </interceptors> <!-- 此默认 interceptor 是针对当前包内所有 action 的，若不为 action 显式指定 interceptor,就会用 default-interceptor-ref--> <!-- 如果某个 action 中引入了 interceptor, 则在这个 action 中此默认 interceptor 就会失效 --> <default-interceptor-ref name="myInterceptorStack"></default-interceptor-ref> <action name="register" class="e.hust.action.RegisterAction"> <result name="input">/register.jsp</result> <result>/result.jsp</result> </action> </package> </struts> 3. extends MethodFilterInterceptor 的拦截器如何配置哪些方法该拦截、哪些方法不 该拦截(针对方法拦截的配置) <struts> <package name="struts2" extends="struts-default"> <interceptors> <interceptor name="myInterceptor3" class="e.hust.interceptor.MyInterceptor3"></interceptor> </interceptors> <action name="register" class="e.hust.action.RegisterAction" method="queryAll"> <result name="input">/register.jsp</result> <result>/result.jsp</result> <!-- myInterceptor3 拦截器只对 RegisterAction 中的 queryAll()方法和 insert()方法进行了拦截, 其他方法未进行拦截 --> <interceptor-ref name="myInterceptor3"> <param name="includeMethods">queryAll, execute</param> </interceptor-ref> <interceptor-ref name="defaultStack"></interceptor-ref> </action> <action name="register" class="e.hust.action.RegisterAction" method="insert"> <result <span 2, 实现 interceptor 类似于 filter, 自定义 filter 是实现 javax.servlet.Filter 来完成， 而 interceptor 类似，它通过实现 com.opensymphony.xwork2.interceptor.Interceptor 来自定义实现。 该接口提供了三个方法： 1) void init(); 在该拦截器被初始化之后，在该拦截器执行拦截之前，系统回调该 方法。对于每个拦截器而言，此方法只执行一次。 2) void destroy();该方法跟 init()方法对应。在拦截器实例被销毁之前，系统将 回调该方法。 3) String intercept(ActionInvocation invocation) throws Exception; 该方法是用户需要实现的拦截动作。该方法会返回一个字符串作为逻辑视图。 除此之外，继承类 com.opensymphony.xwork2.interceptor.AbstractInterceptor 是更简单的一种实现拦截器类的方式，因为此类提供了 init()和 destroy()方法的空实现， 这样我们只需要实现 intercept 方法。 3， 应用 import java.util.Map; import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionInvocation; import com.opensymphony.xwork2.interceptor.AbstractInterceptor; /** * 权限检查拦截器 * * @author qiujy * @version 1.0 */ public class AuthorizationInterceptor extends AbstractInterceptor { /* * 拦截 Action 处理的拦截方法 * */ public String intercept(ActionInvocation invocation) throws Exception { //清除后台页面的缓存 HttpServletResponse response = ServletActionContext.getResponse(); // ServletActionContext 自动提供，可让其获得 request,session,response 等 response.setHeader("Pragma","No-cache"); response.setHeader("Cache-Control","no-cache"); response.setHeader("Expires","0"); Map session = invocation.getInvocationContext().getSession(); String userName = (String) session.get("userName"); if (null != userName && userName.equals("test")) { System.out.println("拦截器：合法用户登录---"); return invocation.invoke(); //保持原来的流程不改变 } else { System.out.println("拦截器：用户未登录---"); return Action.LOGIN; //返回到配置文件中名字为 login 的 action } } }
Ⅵ jsp/servlet过滤器和struts2拦截器的有什么区别
拦截器和过滤器的区别：
1、拦截器是基于java的反射机制的，而过滤器是基于函数回调
2、过滤器依赖与servlet容器，而拦截器不依赖与servlet容器
3、拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用
4、拦截器可以访问action上下文、值栈里的对象，而过滤器不能
5、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次
拦截器
:是在面向切面编程的就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。
下面通过实例来看一下过滤器和拦截器的区别：
使用拦截器进行/admin 目录下jsp页面的过滤
[html] view plain
<package name="newsDemo"
extends="struts-default"
namespace="/admin">
<interceptors>
<interceptor name="auth"
class="com.test.news.util.AccessInterceptor" />
<interceptor-stack name="authStack">
<interceptor-ref
name="auth" />
</interceptor-stack>
</interceptors>
<!-- action -->
<action name="newsAdminView!*" class="newsAction"
method="{1}">
<interceptor-ref
name="defaultStack"/>
<interceptor-ref
name="authStack">
</interceptor-ref>
下面是我实现的Interceptor class:
[java] view plain
package com.test.news.util;
import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import
com.opensymphony.xwork2.ActionInvocation;
import
com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import
com.test.news.action.AdminLoginAction;
/**
*
@author chaoyin
*/
public class AccessInterceptor
extends AbstractInterceptor {
private static final long
serialVersionUID = -4291195782860785705L;
@Override
public String intercept（ActionInvocation actionInvocation） throws
Exception {
ActionContext actionContext =
actionInvocation.getInvocationContext（）；
Map session =
actionContext.getSession（）；
//except login action
Object action = actionInvocation.getAction（）；
if （action
instanceof AdminLoginAction） {
return
actionInvocation.invoke（）；
}
//check
session
if（session.get（"user"）==null ）{
return
"logout";
}
return actionInvocation.invoke（）；//go
on
}
}
过滤器：是在javaweb中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的
action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉），或者在传入servlet或者
struts的action前统一设置字符集，或者去除掉一些非法字符。
使用过滤器进行/admin
目录下jsp页面的过滤，首先在web.xml进行过滤器配置：
[html] view plain
<filter>
<filter-name>access
filter</filter-name>
<filter-class>
com.test.news.util.AccessFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>access filter</filter-name>
<url-pattern>/admin/*</url-pattern>
</filter-mapping>
下面是过滤的实现类：
[java] view
plain
package com.test.news.util;
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;
import
javax.servlet.http.HttpServletRequest;
import
javax.servlet.http.HttpServletResponse;
import
javax.servlet.http.HttpSession;
public class AccessFilter
implements Filter {
/**
* @author chaoyin
*/
public void destroy（） {
}
public void doFilter（ServletRequest arg0, ServletResponse arg1,
FilterChain filterChain） throws IOException, ServletException {
HttpServletRequest request = （HttpServletRequest）arg0;
HttpServletResponse response = （HttpServletResponse）arg1;
HttpSession session = request.getSession（）；
if（session.getAttribute（"user"）== null &&
request.getRequestURI（）。indexOf（"login.jsp"）==-1 ）{
response.sendRedirect（"login.jsp"）；
return ;
}
filterChain.doFilter（arg0, arg1）；
}
public void init（FilterConfig arg0） throws ServletException {
}
}
摘自网络--
Ⅶ struts2是filter还是servlet
filter也是servlet,struts2也是通过servlet实现的，如果你能自己写一个一个structs，你会发现，你写的就是servlet
Ⅷ STruts2过滤器怎么拦截所有!save方法
写一个servlet ：UserFilter 实现Filter 接口
重写方法：public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain){
if(session.getAttribut("user")==null) 异常处理；内
filterChain.doFilter(request, response);
}
修改web.xml增加servlet配置：容
<servlet>
<servlet-name>UserFilter</servlet-name>
<servlet-class>****UserFilter</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UserFilter</servlet-name>
<url-pattern>*</url-pattern>
</servlet-mapping-->
Ⅸ Struts与serverlet的不同
Servlet: JavaEE规范
1）sun公司提供的JavaEE规范，主要用于开发web应用；
2）简单的说：servlet就是一个使用了一定协议以及Api的java程序；
专业的说：servlet是一套开发web应用的规范，其内部实现全部由java语言实现，具有java语言的一切优点。开发的过程是用java开发java应用。换句话说就是使用一些已经写好的java程序去实现一定的业务，即也就是结合业务调用对象以及方法的过程；
3）servlet的主要实现都位于：javax.servlet.*以及javax.servlet.http.*两个包下；
4）CGI的替代品；
5）一个可以处理多用户请求的程序，处理方式：同一份代码，用线程来控制请求处理；servlet api明确说明servlet不是线程安全的，原因是所有的请求处理都是在一个Servlet里面完成的。
Struts: 最早的MVC开源框架
1）是apache组织基于MVC模式开发的开源的单点控制的web应用框架(framework)；
2）struts2的核心是WebWork2，继承了webwork2的血统，所以跟struts1.x有很大的区别，更类似于WebWork；
3）struts2是一个基于MVC Model 2的单点控制的Web应用框架；
一个是规范，一个是框架，区别大着呢！
Ⅹ struts2 是过滤器还是servlet
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
看名字