精华内容
下载资源
问答
  • Struts1自学教程

    万人学习 2015-04-29 21:31:43
    Struts1是Struts2学习的基础,懂了Struts1,学习Struts2会变得很轻松。很多遗留系统,需要维护,也需要我们懂点Struts1的知识。本次课程为14个学时,将从Struts1.x的环境搭建以及技术准备入手,利用Struts1.x实现...
  •  1.Struts1中,Action类必须继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。   2.Struts2中,Action类可以实现一个Action接口,也可实现其他接口,使可选和定制的服务成为可能。Struts2...

    从Action类上分析:

            1.Struts1中,Action类必须继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。 

            2.Struts2中,Action类可以实现一个Action接口,也可实现其他接口,使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的,任何有execute标识的POJO对象都可以用作Struts2的Action对象。

    从Servlet 依赖分析: 

             1. Struts1中, Action 依赖于Servlet API 。当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。

            2. Struts2中, Action不依赖于容器,允许Action脱离容器单独被测试。如果需要,Struts2中Action仍然可以访问初始的request和response。但是,其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

    从Action线程模式分析: 

            1. Struts1中,Action是单例模式并且必须是线程安全的,因为仅有Action的一个实例来处理所有的请求。Struts1中的单例策略限制了Action能作的事,并且要在开发时特别小心。Action资源必须是线程安全的或同步的。 

            2. Struts2中,Action对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,servlet容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)

    展开全文
  • struts1和struts2的区别

    千次阅读 2019-04-18 10:49:02
    下面有关struts1和struts2的区别,描述错误的是? B A Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口 B Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例...

    下面有关struts1和struts2的区别,描述错误的是? B

    • A Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口

    • B Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例模式并且必须是线程安全的

    • C Struts1 Action 依赖于Servlet API,Struts 2 Action不依赖于容器,允许Action脱离容器单独被测试

    • D Struts1 整合了JSTL,Struts2可以使用JSTL,但是也支持OGNL

    解析:
    从action类上分析:

    1.Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
    2. Struts 2 Action类可以实现一个Action接口,也可实现其他接口,使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的,任何有execute标识的POJO对象都可以用作Struts2的Action对象。

    从Servlet 依赖分析:

    1. Struts1 Action 依赖于Servlet API,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
      4.Struts 2 Action不依赖于容器,允许Action脱离容器单独被测试。如果需要,Struts2 Action仍然可以访问初始的request和response。但是,其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

    从action线程模式分析:

    1. Struts1 Action是单例模式并且必须是线程安全的,因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事,并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
    2. Struts2 Action对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,servlet容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
    展开全文
  • 入门Struts1第一讲——Struts1入门就这么简单

    万次阅读 多人点赞 2016-09-24 17:59:12
    我们先来学习Struts1框架,然后再过渡到Struts2框架的学习中。下面我们开始学习Struts1框架。Struts简介Struts是apache开发的一个web层的框架,它主要用于简化web层的开发,Struts针对web层的一些常用操作,例如: ...

    现在终于进入框架的学习中了,后面还有好几个框架等待着我们呢!我们先来学习Struts1框架,然后再过渡到Struts2框架的学习中。下面我们开始学习Struts1框架之旅。

    Struts1简介

    Struts1是Apache开发的一个web层的框架,它主要用于简化web层的开发,Struts1针对web层的一些常用操作,例如:

    • 表单数据的封装、校验和数据的回显;
    • 国际化开发;
    • 文件上传;
    • 异常处理;
    • 等等…

    Struts1都提供了相应的简化,因此,很多web开发人员都会选用Struts1进行web开发。我们不禁就要问,Struts1是如何做到简化web层开发的呢?传统方式上都是在Servlet中编写请求处理代码,如下图:
    在这里插入图片描述
    学了Struts1之后,是在Action中编写请求处理代码,为什么这样做呢?因为Struts1作者帮我们写好了一个ActionServlet,他写这个Servlet的目的是希望所有请求都交给它预处理,它预处理完后,再调用你写的Action处理请求。当然,Struts1的ActionServlet在对请求进行预处理时,会帮我们做好一些基础性的工作,我们编写Action处理请求时,就可以省去一些编码量了,从而简化开发。如下图:
    在这里插入图片描述
    学了Struts1框架时,初学者需要明确的几个问题:

    • Struts1只是一个web层的框架,它用于规范并简化web层的开发,它是对Servlet、JSP等web开发技术的封装。在开发中大家遇到问题,如果发现Struts1不给力,照样可以使用web技术解决,两种技术混用不会有任何问题;
    • web基础最重要
    • Struts1只是一个web层的框架,它只是用于解决web层的问题,千万不要想着用Struts1去操纵数据库。

    Struts1开发快速入门

    现在以一个我们常见的用户注册案例来快速入门Struts1。首先,编写register.jsp注册页面,表单提交给register.do处理。register.jsp页面内容如下:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>用户注册页面</title>
    </head>
    <body>
    	<form action="${pageContext.request.contextPath }/register.do" method="post">
    		用户名:<input type="text" name="username" /><br/>
    		密码:<input type="password" name="password" /><br/>
    		电子邮箱:<input type="text" name="email" /><br/>
    		<input type="submit" value="注册" />
    	</form>
    </body>
    </html>
    

    温馨提示:Struts1框架规定了若是提交请求,请求应交给xxx.do去处理,大家只须记住即可,不要问为何,因为我也不知道。
    然后,用户填写完注册信息,点击注册按钮,请求就要交给Struts1去处理,这时需要在web工程中导入Struts1开发包。那我们怎么知道要导入哪些jar包呢?可以在struts-1.3.8-all\struts-1.3.8\lib目录下查找到我们所需的Struts1开发包,如下图:
    在这里插入图片描述
    从lib目录中我们可以看到,Struts1开发所需的jar包,有些是我们非常熟悉的,比如:

    • commons-beanutils-1.7.0.jar
    • commons-fileupload-1.1.1.jar
    • commons-io-1.1.jar
    • commons-logging-1.0.4.jar

    只不过是这些jar包的版本比较低而已,但是如下的两个jar包由于版本太低了,我们遗弃了。

    • jstl-1.0.2.jar
    • standard-1.0.2.jar

    若要是项目中需要使用到JSTL标签,可以使用较新的jar包。那这样,在lib目录下,除了以上两个jar包,我们将所有jar包拷贝到项目中去,作为Struts1开发包。
    接着,要在web.xml文件中配置Struts1框架提供的ActionServlet,使其处理所有以.do为结尾的请求。

    <servlet>
    	<servlet-name>ActionServlet</servlet-name>
    	<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    	
    	<!-- ActionServlet是基于struts-config.xml配置文件工作的,该配置文件可通过初始化参数配置进去  -->
    	<init-param>
    		<param-name>config</param-name>
    		<param-value>/WEB-INF/struts-config.xml</param-value>
    	</init-param>
    	
    	<!-- 该ActionServlet希望在web应用程序启动的时候就将其创建出来,处理所有的请求 -->
    	<load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
    	<servlet-name>ActionServlet</servlet-name>
    	<url-pattern>*.do</url-pattern>
    </servlet-mapping>
    

    顺其自然地,还应在WEB-INF目录下编写ActionServlet工作时使用的配置文件struts-config.xml,配置当ActionServlet收到register.do请求时,调用一个名称为RegisterAction的Action处理。这样配置文件struts-config.xml的内容为:

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!DOCTYPE struts-config PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
              "http://struts.apache.org/dtds/struts-config_1_3.dtd">
    
    <struts-config>
    	<action-mappings>
    		<action path="/register" type="cn.liayun.web.action.RegisterAction"></action>
    	</action-mappings>
    </struts-config>
    

    还记得以前,我们做用户注册的案例时,需要将用户提交过来的注册信息封装到一个formbean中吧!现在学了Struts1之后,Struts1会自动封装请求数据。Struts1的ActionServlet的功能非常强大,我们只需要在它的配置文件(struts-config.xml文件)中配置一下,它就可以自动把请求数据封装到用户指定的formbean中。并且Struts1在调用开发人员编写的Action时,会把封装了数据的formbean传给Action。这样,可以省去开发人员在Action中手工获取客户端提交的数据,减轻编码工作量。这样配置文件struts-config.xml的内容就为:

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!DOCTYPE struts-config PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
              "http://struts.apache.org/dtds/struts-config_1_3.dtd">
    
    <struts-config>
    	<form-beans>
    		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
    	</form-beans>
    
    	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
    		<action path="/register" name="registerForm" type="cn.liayun.web.action.RegisterAction"></action>
    	</action-mappings>
    </struts-config>
    

    接着要在cn.liayun.web.formbean包下创建出封装用户提交过来的注册信息的formbean(RegisterFormBean.java)了。

    package cn.liayun.web.formbean;
    
    import org.apache.struts.action.ActionForm;
    
    public class RegisterFormBean extends ActionForm {
    	
    	private String username;
    	private String password;
    	private String email;
    	
    	public String getUsername() {
    		return username;
    	}
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	public String getEmail() {
    		return email;
    	}
    	public void setEmail(String email) {
    		this.email = email;
    	}
    	
    }
    

    温馨提示:用于封装数据的formbean要继承Struts1的ActionForm类
    紧接着,我们要编写处理请求的Action——RegisterAction.java,在其execute方法内编码,采用传统方式获取数据,并调用service层完成用户注册,然后转发给相应的jsp页面。

    package cn.liayun.web.action;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;
    
    import cn.liayun.web.formbean.RegisterFormBean;
    
    //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
    public class RegisterAction extends Action {
    
    	@Override
    	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		RegisterFormBean registerForm = (RegisterFormBean) form;
    		String username = registerForm.getUsername();
    		String password = registerForm.getPassword();
    		String email = registerForm.getEmail();
    		try {
    			System.out.println("向数据库中注册" + username + "用户");
    			request.setAttribute("message", "注册成功!!");
    		} catch (Exception e) {
    			request.setAttribute("message", "注册失败!!");
    		}
    		request.getRequestDispatcher("/message.jsp").forward(request, response);//使用传统技术来跳转
    		
    		return null;
    	}
    	
    }
    

    最后,编写用于显示全局消息的message.jsp页面。

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>全局消息显示页面</title>
    </head>
    <body>
    ${message }
    </body>
    </html>
    

    编写完这样一个小程序,我们就算入门Struts1框架了。学习一门技术最重要的是入门,入门之后剩下的就好说了。

    让Struts1实现请求转发

    我们编写处理请求的RegisterAction时,使用的是传统方式的请求转发。但现在我们让Struts1实现请求转发,我们在编写Action时,无须在Action内手工编码进行请求转发,Struts1的ActionServlet在调用Action的execute方法时,可以根据它的返回值,决定调用哪个jsp页面响应用户请求。
    Action.execute方法的返回值ActionForward代表一个转发对象,Struts1的ActionServlet在收到Action.execute方法的返回值——ActionForward后,会取出该对象封装的转发地址,进行请求转发。用图表示即为:
    在这里插入图片描述
    这样,RegisterAction类的代码可以修改为:

    package cn.liayun.web.action;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;
    
    import cn.liayun.web.formbean.RegisterFormBean;
    
    //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
    public class RegisterAction extends Action {
    
    	@Override
    	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		RegisterFormBean registerForm = (RegisterFormBean) form;
    		String username = registerForm.getUsername();
    		String password = registerForm.getPassword();
    		String email = registerForm.getEmail();
    		try {
    			System.out.println("向数据库中注册" + username + "用户");
    			request.setAttribute("message", "注册成功!!");
    		} catch (Exception e) {
    			request.setAttribute("message", "注册失败!!");
    		}
    		
    		//request.getRequestDispatcher("/message.jsp").forward(request, response);//使用传统技术来跳转
    		
    		ActionForward forward = new ActionForward("/message.jsp");//转发地址写死了,并不好
    		return forward;
    	}
    	
    }
    

    我们也可以让Struts1根据配置实现转发。在Struts1的配置文件(struts-config.xml文件)中,可以配置forward标签,它用于封装一个转发地址。如:
    在这里插入图片描述
    这样,Struts1的配置文件(struts-config.xml文件)就要修改为:

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!DOCTYPE struts-config PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
              "http://struts.apache.org/dtds/struts-config_1_3.dtd">
    
    <struts-config>
    	<form-beans>
    		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
    	</form-beans>
    
    	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
    	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
    		<action path="/register" name="registerForm" type="cn.liayun.web.action.RegisterAction">
    			<forward name="message" path="message.jsp" />
    		</action>
    	</action-mappings>
    </struts-config>
    

    Struts1的ActionServlet在调用Action时,会把Action的配置信息封装到一个ActionMapping对象中,并传递给Action。因此,开发人员在编写Action时,无须硬编码指定转发地址,可以通过ActionMapping对象,获得配置文件中配置的转发地址,从而实现转发。如下图:
    在这里插入图片描述
    这样,RegisterAction类的代码又将修改为:

    package cn.liayun.web.action;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;
    
    import cn.liayun.web.formbean.RegisterFormBean;
    
    //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
    public class RegisterAction extends Action {
    
    	@Override
    	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		RegisterFormBean registerForm = (RegisterFormBean) form;
    		String username = registerForm.getUsername();
    		String password = registerForm.getPassword();
    		String email = registerForm.getEmail();
    		try {
    			System.out.println("向数据库中注册" + username + "用户");
    			request.setAttribute("message", "注册成功!!");
    		} catch (Exception e) {
    			request.setAttribute("message", "注册失败!!");
    		}
    		
    		ActionForward forward = new ActionForward(mapping.getForward());//处理完了,到底要跳到哪儿去,不需要在程序中写死,就在配置文件里面配置好就行了!
    		return forward;
    	}
    	
    }
    

    甚至,我们也可以写成下面这个样子:

    package cn.liayun.web.action;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;
    
    import cn.liayun.web.formbean.RegisterFormBean;
    
    //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
    public class RegisterAction extends Action {
    
    	@Override
    	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		RegisterFormBean registerForm = (RegisterFormBean) form;
    		String username = registerForm.getUsername();
    		String password = registerForm.getPassword();
    		String email = registerForm.getEmail();
    		try {
    			System.out.println("向数据库中注册" + username + "用户");
    			request.setAttribute("message", "注册成功!!");
    		} catch (Exception e) {
    			request.setAttribute("message", "注册失败!!");
    		}
    		
    		return mapping.findForward("message");
    	}
    	
    }
    

    整个流程用图来表示就是这样的:
    在这里插入图片描述

    Struts1工作原理与源码分析

    我们一定要读Struts1的源码,然后分析Struts1的工作流程,这对我们深入理解Struts1有极大的帮助。在读Struts1的源码时,有一个小细节需要我们注意:由于我们使用的是struts-1.3.8-all,这个版本是Struts1的最终版本,所以我们读它的源码时,挺费劲的,为了让其源码比较好读一点,我们可以在Struts1的配置文件(struts-config.xml文件)中配置Struts1.2采用的请求处理器,并且在实际开发中,若真有项目是用的Struts1框架,那么使用的一般都是Struts1.2版本的。

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!DOCTYPE struts-config PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
              "http://struts.apache.org/dtds/struts-config_1_3.dtd">
    
    <struts-config>
    	<form-beans>
    		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
    	</form-beans>
    
    	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
    	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
    		<action path="/register" name="registerForm" type="cn.liayun.web.action.RegisterAction">
    			<forward name="message" path="message.jsp" />
    		</action>
    	</action-mappings>
    	
    	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
        <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
    </struts-config>
    

    然后大家就可以使用断点跟踪的方式查看Struts1的源码了。读了Struts1的源码之后,我们可以得出一些结论:
    在这里插入图片描述
    在这里插入图片描述

    Struts1的配置

    Struts1配置文件常用属性

    Struts1配置文件常用属性有:
    在这里插入图片描述
    下面我们来逐一地详解这些属性。

    • path:指定action处理的地址;
    • type:指定处理请求的Action的完整类名;
    • name:指定使用哪个formbean封装请求参数。

    以上三个参数我们都知道了,就没有说的必要了,接下来看看我们并未熟知的属性。

    • scope:指定把formbean存放到哪个域对象中,默认为session。
      我们还是举用户注册的案例来讲解这个属性。若要是不指定这个属性,默认把formbean存放到session这个域中,是不是真是这样呢?我们可以用以下代码来测试:

      package cn.liayun.web.action;
      
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      
      import org.apache.struts.action.Action;
      import org.apache.struts.action.ActionForm;
      import org.apache.struts.action.ActionForward;
      import org.apache.struts.action.ActionMapping;
      
      import cn.liayun.web.formbean.RegisterFormBean;
      
      //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
      public class RegisterAction extends Action {
      
      	@Override
      	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
      			HttpServletResponse response) throws Exception {
      		RegisterFormBean registerForm = (RegisterFormBean) request.getSession().getAttribute("registerForm");
      		String username = registerForm.getUsername();
      		String password = registerForm.getPassword();
      		String email = registerForm.getEmail();
      		try {
      			System.out.println("向数据库中注册" + username + "用户");
      			request.setAttribute("message", "注册成功!!");
      		} catch (Exception e) {
      			request.setAttribute("message", "注册失败!!");
      		}
      		
      		return mapping.findForward("message");
      	}
      	
      }
      

      经测试,发现若要是不指定这个属性,真是默认把formbean对象存放到session这个域中。但是session域的生命周期比较长,把formbean对象存到其中并不太好,session域中将来要存储的东西很多,要是什么东西都往session域中存,难不保计算机内存会溢出。所以,一般来说,我们把formbean存放到request域中,这样就要修改Struts1的配置文件了。

      <?xml version="1.0" encoding="UTF-8" ?>
      
      <!DOCTYPE struts-config PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
                "http://struts.apache.org/dtds/struts-config_1_3.dtd">
      
      <struts-config>
      	<form-beans>
      		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
      	</form-beans>
      
      	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
      	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
      		<action path="/register" 
      				name="registerForm" 
      				type="cn.liayun.web.action.RegisterAction"
      				scope="request">
      			<forward name="message" path="message.jsp" />
      		</action>
      	</action-mappings>
      	
      	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
          <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
      </struts-config>
      

      这样我们处理请求的RegisterAction就要写为:

      package cn.liayun.web.action;
      
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      
      import org.apache.struts.action.Action;
      import org.apache.struts.action.ActionForm;
      import org.apache.struts.action.ActionForward;
      import org.apache.struts.action.ActionMapping;
      
      import cn.liayun.web.formbean.RegisterFormBean;
      
      //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
      public class RegisterAction extends Action {
      
      	@Override
      	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
      			HttpServletResponse response) throws Exception {
      		RegisterFormBean registerForm = (RegisterFormBean) request.getAttribute("registerForm");
      		String username = registerForm.getUsername();
      		String password = registerForm.getPassword();
      		String email = registerForm.getEmail();
      		try {
      			System.out.println("向数据库中注册" + username + "用户");
      			request.setAttribute("message", "注册成功!!");
      		} catch (Exception e) {
      			request.setAttribute("message", "注册失败!!");
      		}
      		
      		return mapping.findForward("message");
      	}
      	
      }
      
    • attribute:指定formbean存储的key,不设默认为name属性的值。
      从上面的代码中可知,formbean存放在request域中的key默认就是name属性的值,但大家也可以修改formbean存放在request域中的key,如:

      <?xml version="1.0" encoding="UTF-8" ?>
      
      <!DOCTYPE struts-config PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
                "http://struts.apache.org/dtds/struts-config_1_3.dtd">
      
      <struts-config>
      	<form-beans>
      		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
      	</form-beans>
      
      	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
      	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
      		<action path="/register" 
      				name="registerForm" 
      				type="cn.liayun.web.action.RegisterAction"
      				scope="request"
      				attribute="liayun">
      			<forward name="message" path="message.jsp" />
      		</action>
      	</action-mappings>
      	
      	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
          <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
      </struts-config>
      

      那么处理请求的RegisterAction就要写为:

      package cn.liayun.web.action;
      
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      
      import org.apache.struts.action.Action;
      import org.apache.struts.action.ActionForm;
      import org.apache.struts.action.ActionForward;
      import org.apache.struts.action.ActionMapping;
      
      import cn.liayun.web.formbean.RegisterFormBean;
      
      //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
      public class RegisterAction extends Action {
      
      	@Override
      	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
      			HttpServletResponse response) throws Exception {
      		RegisterFormBean registerForm = (RegisterFormBean) request.getAttribute("liayun");
      		String username = registerForm.getUsername();
      		String password = registerForm.getPassword();
      		String email = registerForm.getEmail();
      		try {
      			System.out.println("向数据库中注册" + username + "用户");
      			request.setAttribute("message", "注册成功!!");
      		} catch (Exception e) {
      			request.setAttribute("message", "注册失败!!");
      		}
      		
      		return mapping.findForward("message");
      	}
      	
      }
      
    • input:指定formbean的数据是由哪个页面提供的,提供此属性的目的在于formbean校验失败时,程序方便跳回formbean的输入页面,显示校验失败信息。在这儿,我就不举例说明了,因为后面在借助Struts1完成表单校验时就会用到这个属性;

    • forward:指定收到请求时,跳转到相应的jsp页面,如果配置了此属性,则Action将不再被调用。
      这个属性还是比较实用的,试想我们浏览一个网站,都是首页给我们提供这个网站的一些功能,例如该网站会在首页挂一个注册的超链接,首页index.jsp的内容如下:

      <%@ page language="java" import="java.util.*" contentType="text/html; charset=UTF-8"
          pageEncoding="UTF-8"%>
      <%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
      <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
      <html>
      <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>网站首页</title>
      </head>
      <body>
      	<a href="${pageContext.request.contextPath }/registerUI.do">注册</a>
      </body>
      </html>
      

      用户点击注册超链接,以前都是将请求交给一个Servlet,然后通过这个Servlet跳转到注册页面,现在学了Struts1之后,就不用这么做了,我们只须这样修改Struts1的配置文件:

      <?xml version="1.0" encoding="UTF-8" ?>
      
      <!DOCTYPE struts-config PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
                "http://struts.apache.org/dtds/struts-config_1_3.dtd">
      
      <struts-config>
      	<form-beans>
      		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
      	</form-beans>
      
      	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
      	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
      		<action path="/register" 
      				name="registerForm" 
      				type="cn.liayun.web.action.RegisterAction"
      				scope="request"
      				attribute="liayun">
      			<forward name="message" path="message.jsp" />
      		</action>
      		
      		<action path="/registerUI" forward="/register.jsp"></action>
      	</action-mappings>
      	
      	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
          <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
      </struts-config>
      

      这样当用户点击注册超链接时,就会跳转到用户注册页面。

    • include:指定收到请求时,进行页面包含。这个属性不是很常用

    • unknown:如果Action把该属性设置为true,则它可以处理客户机发出的所有无效的.do请求,默认值为false。
      例如有些人吃饱了没事干,会通过这样的URL地址访问web服务器,如http://localhost:8080/Struts1Sample/dertettytuyiioioip.do,明显web服务器就没有对应的Action对这样的请求进行处理,所以会报这样的错误:
      在这里插入图片描述
      而要想不向用户弹出这样不友好的错误页面,可以在Struts1的配置文件中添加:
      在这里插入图片描述
      这样Struts1的配置文件就为:

      <?xml version="1.0" encoding="UTF-8" ?>
      
      <!DOCTYPE struts-config PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
                "http://struts.apache.org/dtds/struts-config_1_3.dtd">
      
      <struts-config>
      	<form-beans>
      		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
      	</form-beans>
      
      	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
      	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
      		<action path="/register" 
      				name="registerForm" 
      				type="cn.liayun.web.action.RegisterAction"
      				scope="request"
      				attribute="liayun">
      			<forward name="message" path="message.jsp" />
      		</action>
      		
      		<action path="/registerUI" forward="/register.jsp"></action>
      		
      		<action path="/error" unknown="true" forward="/WEB-INF/jsp/error.jsp"></action>
      	</action-mappings>
      	
      	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
          <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
      </struts-config>
      

      接下来就要创建出专门处理错误的页面了,error.jsp页面的内容如下:

      <%@ page language="java" contentType="text/html; charset=UTF-8"
          pageEncoding="UTF-8"%>
      <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
      <html>
      <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>专门处理错误的页面</title>
      </head>
      <body>
      	出错了!!!
      </body>
      </html>
      

      这样,当有些人吃饱了没事干,通过这样的URL地址,如http://localhost:8080/Struts1Sample/dertettytuyiioioip.do访问web服务器,那么就会跳转到error.jsp页面中。
      在这里插入图片描述
      其实在实际生活中人们并不会通过这样的URL地址去访问web服务器,更加常见的是使用这样的URL地址(如http://localhost:8080/Struts1Sample/dertettytuyiioioip)去访问web服务器,这时由于并不是.do请求,所以Struts1就起不了任何作用了。如果要避免这样的情况,我们还是要像以前一样在web.xml文件中配置这样的代码:

      <error-page>
          <error-code>404</error-code>
          ...
      </error-page>
      
      <error-page>
          <error-code>500</error-code>
          ...
      </error-page>
      
    • parameter:配置Action参数,调用ActionMapping.getParameter方法可以获得这里配置的参数。我们修改Struts1的配置文件为:

      <?xml version="1.0" encoding="UTF-8" ?>
      
      <!DOCTYPE struts-config PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
                "http://struts.apache.org/dtds/struts-config_1_3.dtd">
      
      <struts-config>
      	<form-beans>
      		<form-bean name="registerForm" type="cn.liayun.web.formbean.RegisterFormBean"></form-bean>
      	</form-beans>
      
      	<!-- Struts1在调用RegisterAction的时候,它会把所有<action>...</action>中的配置信息封装到ActionMapping对象中 -->
      	<action-mappings>            <!-- Struts1收到register请求的时候,将把请求中的所有数据封装到registerForm对象中 -->
      		<action path="/register" 
      				name="registerForm" 
      				type="cn.liayun.web.action.RegisterAction"
      				scope="request"
      				attribute="liayun"
      				parameter="method">
      			<forward name="message" path="message.jsp" />
      		</action>
      		
      		<action path="/registerUI" forward="/register.jsp"></action>
      		
      		<action path="/error" unknown="true" forward="/WEB-INF/jsp/error.jsp"></action>
      	</action-mappings>
      	
      	<!-- 配置请求处理器(来处理请求),Struts1.2采用的请求处理器是RequestProcessor -->
          <controller processorClass="org.apache.struts.action.RequestProcessor"></controller>
      </struts-config>
      

      然后为了获得配置Action的参数,我们要修改RegisterAction类的代码为:

      package cn.liayun.web.action;
      
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      
      import org.apache.struts.action.Action;
      import org.apache.struts.action.ActionForm;
      import org.apache.struts.action.ActionForward;
      import org.apache.struts.action.ActionMapping;
      
      import cn.liayun.web.formbean.RegisterFormBean;
      
      //该RegisterAction是由Struts1来调用,Struts1会调用它的execute方法处理请求
      public class RegisterAction extends Action {
      
      	@Override
      	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
      			HttpServletResponse response) throws Exception {
      		RegisterFormBean registerForm = (RegisterFormBean) request.getAttribute("liayun");
      		String username = registerForm.getUsername();
      		String password = registerForm.getPassword();
      		String email = registerForm.getEmail();
      		
      		System.out.println(mapping.getParameter());
      		
      		try {
      			System.out.println("向数据库中注册" + username + "用户");
      			request.setAttribute("message", "注册成功!!");
      		} catch (Exception e) {
      			request.setAttribute("message", "注册失败!!");
      		}
      		
      		return mapping.findForward("message");
      	}
      	
      }
      

      这样会在Eclipse的控制台中输出method。

    • classname:<action>标签和所有的配置信息使用哪个对象封装,默认值为ActionMapping对象。千万注意不要与type属性弄混

    • validate:请求参数封装到formbean中后,是否让Struts1自动调用formbean的validate方法进行数据校验。默认为true。

    这样我们就把Struts1配置文件的常用属性过了一遍了。这就是Struts1入门了,涉及到的知识还是蛮多的哟!写到这里给自己一个赞!!

    展开全文
  • Struts1 和 Struts2

    万次阅读 多人点赞 2013-03-15 20:46:06
    对于有着丰富的Struts1.x开发经验的朋友来说,都十分的清楚Action是整个Struts框架的核心内容,当然Struts2也不例外。不过,Struts1.x与Struts2的Action模型很大的区别。 Struts2和Struts1.x的差别,最明显的就是...
    
    

    关于Struts2的出现缘由和好处就不多说啦,看了几篇总结的不错的文章,整理下贴出来,共同学习了。

    Action的区别

    对于有着丰富的Struts1.x开发经验的朋友来说,都十分的清楚Action是整个Struts框架的核心内容,当然Struts2也不例外。不过,Struts1.xStruts2Action模型很大的区别。

    Struts2Struts1.x的差别,最明显的就是Struts2是一个pull-MVC架构。这是什么意思呢?从开发者角度看,就是说需要显示给用户的数据可以直接从Action中获取,而不像Struts1.x那样,必须把相应的Bean存到PageRequest或者Session中才能获取。Struts1.x必须继承org.apache.struts.action.Action或者其子类,表单数据封装在FormBean中。Struts2无须继承任何类型或实现任何接口,表单数据包含在Action中,通过GetterSetter获取(如下面的ActionForStruts2的代码示例)。

    虽然,在理论上Struts2Action无须实现任何接口或者是继承任何的类,但是,在实际编程过程中,为了更加方便的实现Action,大多数情况下都会继承com.opensymphony.xwork2.ActionSupport类,并且重载(Override)此类里的Stringexecute()方法。如下所示:

    package ActionDiffer;
    
     import java.text.DateFormat;
    
     import java.util.Date;
    
     import com.opensymphony.xwork2.ActionSupport;
    
     public class ActionForStruts2 extends ActionSupport {
    
         private String message;
    
         public String getMessage() {
    
             return message;
    
        }
        @Override
         public String execute() {
            message = " This is hello from strtuts2. Now is: " + DateFormat.getInstance().format( new Date());
             return SUCCESS;
        }
    }

    首先,从ActionForStruts2可以看出,返回的对象不是ActionForward,而是String。如果你不喜欢以字符串的形式出现在你的代码中,有个Helper接口Action可以以常量方式提供常见结果,如“success”、“none”、“error”、“input”和“login”。

    另外,按照惯例,在Struts1.x中只有“execute”方法能调用Action, 但在Struts2中并非必要,任何声明为publicString methodName() 方法,都能通过配置来调用Action

    最后,和Struts1.x最大的革命性的不同是,Struts2处理Action过程中调用的方法(“execute”方法)是不带参数的。那如何获取所需要的对象呢?答案是使用IoCSpring框架使得这个模式流行起来,然而Struts2的前身(WebWork)也同时应用上了这个模式。

    关于Action补充文章:Struts 2.0Action讲解

    IOC(不了解这个可以去看我前面的文章)

    众所周知,Struts2是以Webwork2作为基础发展出来。而在Webwork2.2之前的Webwork版本,其自身有一套控制反转的实现,Webwork2.2Spring框架的如火如荼发展的背景下,决定放弃控制反转功能的开发,转由Spring实现。值得一提的是,Spring确实是一个值得学习的框架,因为有越来越多的开源组件(如iBATIS等)都放弃与Spring重叠的功能的开发。因此,Struts2推荐大家通过Spring实现控制反转。

    为了更好地了解反转控制,下面来看一个例子,如何利用IoCAction处理过程中可以访问到当前请求HttpServerRequest对象。

    在例子中,使用的依赖注入机制是接口注入。就如其名称一样,接口注入需要的是已经被实现了的接口。这个接口包含了相应属性的setter,为Action提供值。例子中使用了ServletRequestAware接口,如下:

    public interface ServletRequestAware {
        public void setServletRequest(HttpServletRequest request);
    }

    当继承这个接口后,原本简单的Action看起来有点复杂了,但是这时可以获取HttpServerRequest对象来使用了。

    public class IoCForStruts2 implements ServletRequestAware {
       private HttpServletRequest request;
       public void setServletRequest(HttpServletRequest request) {
            this.request = request;
       }
       public String execute() throws Exception {
            // 可以开始使用request对象进行工作了
            return Action.SUCCESS;
       }
    }

    看起来现在这些属性是类级别的,并不是线程安全的,会出现问题。其实在Struts2里并没有问题,因为每个请求过来的时候都会产生一个新的Action对象实例,它并没有和其他请求共享一个对象,所以不需要考虑线程安全问题。

    关于IOC补充内容:Struts 2中实现IoC

    拦截器

    Interceptor(以下译为拦截器),在AOPAspect-OrientedProgramming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。

    Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者定义在一个action执行的前后执行的代码,也可以在一个action执行前阻止其执行。同时也提供了一种可以提取action中可重用的部分的方式。

    Struts1.x的标准框架中不提供任何形式的拦截器,虽一个名为SAIF的附加项目则实现了这样的功能,但它的适用的范围还很有限。

    拦截器是Struts2的一个强有力的工具,有许多功能(feature)都是构建于它之上,如国际化、转换器,校验等。谈到拦截器,还有一个流行的词——拦截器链(InterceptorChain,在Struts2中称为拦截器栈InterceptorStack)。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时,拦截器链中的拦截器就会按其之前定义的顺序被调用。

    Struts2的拦截器实现相对比较简单。当请求到达Struts2ServletDispatcher时,Struts2会查找配置文件,并根据其配置实例化相对的拦截器对象,然后串成一个列表(list),最后一一地调用列表中的拦截器,如图1所示:


    Struts2已经提供丰富多样功能齐全的拦截器实现。读者可以到struts2-all-2.0.6.jarstruts2-core-2.0.6.jar包的struts-default.xml查看关于默认的拦截器与拦截器链的配置。

    作为“框架(framework)”,可扩展性是不可缺少的,因为世上没有放之四海而皆准的东西。虽然,Struts2为我们提供如此丰富的拦截器实现,但是这并不意味我们失去创建自定义拦截器的能力,恰恰相反,在Struts2自定义拦截器是相当容易的一件事。

    关于拦截器补充内容:Struts 2的基石——拦截器(Interceptor

    Struts2Struts1.x的全面比较

    为了对Struts2Strtus1.x进行全面的比较,让读者了解这两种框架各自的优缺点,以便于在自己的项目中,根据实际情况,选择合适的框架,对它们两者进行比较,总结了如下表分析比较。

    特性

    Struts1.x

    Struts2

    Action

    Struts1.x要求Action类要扩展自一个抽象基类。Struts1.x的一个共有的问题是面向抽象类编程而不是面向接口编程。

    Struts2Action类实现了一个Action接口,连同其他接口一起来实现可选择和自定义的服务。Struts2提供一个名叫ActionSupport的基类来实现一般使用的接口。当然,Action接口不是必须的。任何使用execute方法的POJO对象可以被当作Struts 2Action对象来使用。

    线程模型

    Struts1.x Action类是单例类,因为只有一个实例来控制所有的请求。单例类策略造成了一定的限制,并且给开发带来了额外的烦恼。Action资源必须是线程安全或者同步的。

    Struts2 Action对象为每一个请求都实例化对象,所以没有线程安全的问题。(实践中,servlet容器给每一个请求产生许多丟弃的对象,并且不会导致性能和垃圾回收问题)。

    Servlet依赖

    Struts1.xAction类依赖于servlet API,当Action被调用时,以HttpServletRequestHttpServletResponse作为参数传给execute方法。

    Struts2Action和容器无关。Servlet上下文被表现为简单的Maps,允许Action被独立的测试。Struts2Action可以访问最初的请求(如果需要的话)。但是,尽可能避免或排除其他元素直接访问HttpServletRequestHttpServletResponse

    易测性

    测试Struts1.x的主要问题是execute方法暴露了Servlet API这使得测试要依赖于容器)。第三方的扩展,如Struts TestCase,提供了一套Struts1的模拟对象(来进行测试)。

    Struts2Action可以通过初始化、设置属性、调用方法来测试。依赖注入的支持也是测试变得更简单。

    捕获输入

    Struts1.x使用ActionForm对象来捕获输入。象Action一样,所有的ActionForm必须扩展基类。因为其他的JavaBean不能作为ActionForm使用,开发者经常创建多余的类来捕获输入。DynaBeans可以被用来作为替代ActionForm的类来创建。但是,开发者可能是在重新描述(创建)已经存在的JavaBean(仍然会导致有冗余的javabean)。

    Struts2直接使用Action属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己()属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型,包括业务对象,能够用作输入/输出对象。这种ModelDriven特性简化了taglibPOJO输入对象的引用。

    表达式语言

    Struts1.x整合JSTL,所以它使用JSTL的表达式语言。表达式语言有基本的图形对象移动,但是对集合和索引属性的支持很弱。

    Struts2使用JSTL,但是也支持一个更强大和灵活的表达式语言--"Object Graph Notation Language" (OGNL)

    将值绑定到页面

    Struts1.x使用标准JSP机制来绑定对象到页面上下文。

    Struts2使用“ValueStack”技术,使taglib能够访问值而不需要把你的页面(view)和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面(view)。

    类型转换

    Struts1.xActionForm属性经常都是StringStruts 1.x使用Commons-Beanutils来进行类型转换。转换每一个类,而不是为每一个实例配置。

    Struts2使用OGNL进行类型转换。提供基本和常用对象的转换器。

    验证

    Struts1.x支持在ActionFormvalidate方法中手动校验,或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。

    Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验,来支持chain校验子属性

    Action执行控制

    Struts1.x支持每一个模块有单独的Request Processors(生命周期),但是模块中的所有Action必须共享相同的生命周期。

    Struts2支持通过拦截器堆栈(Interceptor Stacks)为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。

    前面已经简要介绍了Struts2的起源,并详细对比了Struts2Struts1.x的差异,读者应该对Struts2的基础有所了解了——包括高层的框架概念和基础的请求流程,并理解Struts1.xStruts2两者之间在Action方面的差别,Struts2加强了对拦截器与IoC的支持,而在Struts1.x中,这些特性是很难想象的。

    同时,读者应该明白:Struts2WebWork的升级,而不是Struts1.x的升级。虽然Struts2提供了与Struts1.x的兼容,但已经不是Struts1.x的升级。对于已有Struts1.x开发经验的开发者而言,Struts1.x的开发经验对于Struts2并没有太大的帮助;相反,对于已经有WebWork开发经验的开发者而言,WebWork的开发经验对Struts2的开发将有很好的借鉴意义。

    via:http://www.blogjava.net/sterning/archive/2007/07/17/130892.htmld  

    展开全文
  • Struts1和Struts2的区别

    2018-02-01 13:48:16
    Struts1和Struts2的区别 Struts 1要求Action类要扩展自一个抽象基类。Struts 1的一个共有的问题是面向抽象类编程而不是面向接口编程。  Struts 2的Action类实现了一个Action接口,连同其他接口一起...
  • struts2与struts1区别二

    千次阅读 2017-08-02 15:40:36
    Struts2与Struts1的区别  Struts2其实并不是一个陌生的Web框架,Struts2是以Webwork的设计思想为核心,吸收了Struts1的优点,因此,可以认为Struts2是Struts1和Webwork结合的产物。 简单来说二者的区别是:...
  • Struts2概述及与Struts1的对比

    千次阅读 2015-12-19 09:58:47
    Struts2 概述1,仍然是一个基于请求响应的MVC框架2,Struts2不是Struts1的升级3,Struts2与Struts1的体系结构差距非常大4,Struts2采用了另一个MVC框架WebWork的核心设计5,Struts2更优秀:松耦合设计。。 Struts1...
  • Struts1和Struts2对比

    千次阅读 2015-03-20 16:12:49
    最近学习了Struts1和Struts2.很多人、很多资料都提到。Struts2不是从Struts1发展而来的。Struts2的前身是WebWork。那它俩到底有多大的不同呢,看了一些资料,下边就来比较比较。一、架构分析Struts1的架构图: 执行...
  • 【Struts 1】Struts1的基本原理和简介

    千次阅读 热门讨论 2016-06-20 19:41:55
    备注:这里介绍的是Struts1的内容,Struts2的内容,会在后续的博客的予以说明! 一、什么是Struts struts的目标是提供一个开发web应用的开源框架,Struts鼓励基于Model2模式来开发程序。关于model2的说明:【drp 10...
  • Struts 1基础入门

    千次阅读 2017-05-18 21:01:06
    学习内容Ø 框架的概念Ø Struts 1体系结构Ø Struts 1运行流程能力目标Ø 了解MVC模式的优缺点Ø 理解框架的概念Ø 会使用MyEclipse进行Struts 1开发 本章简介在上一阶段的学习中,我们通过使用MVC模式进行...
  • SpringMVC、Struts1和Struts2区别

    千次阅读 2017-11-29 20:45:00
    1、 springMVC单例非线程安全,struts1单例非线程安全,struts2线程安全对每个请求都产生一个实例。 2、 springMVC和String1的入口都是servlet,而struts2是Filter。springMVC 的前端总控制器为 ...
  • Struts1详解

    千次阅读 2015-06-04 16:45:25
    最近学习了Struts1,看了几篇博客不错,收藏一下。 源博文地址:http://blog.csdn.net/jiangwei0910410003/article/details/26447539 今天来看一下Struts1的相关知识,其实Struts现在是出名的,每个Web开发者...
  • struts1与struts2的区别

    千次阅读 2015-08-19 13:24:09
    Struts 2是Struts的下一代产品,是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心,采用拦截器的机制来处理...
  • 之前的两篇博文分别介绍了Struts1和Struts2这两个框架的概念和简单的使用流程,但是没有对这个两个框架之间的不同进行详细的说明,接下来就来看看两者到底有哪些不同的地方吧。  区别一:Struts1的Action类必须要...
  • Struts 1基础 为什么重拾Struts 1   曾经是最主流的MVC框架 市场份额依然很大  很多遗留系统中依旧使用 维护和升级都需要熟悉Struts 1Struts 2相比  编码、配置繁琐  侵入性强 例子:使用Struts...
  • Struts1与Struts2的区别

    千次阅读 2012-12-17 20:48:26
    Struts1的学习: 遇到的问题:Struts1.x的ActionForm Struts2的学习: Struts1与Struts2的比较比较: Struts1与Struts2的比较 特性 Struts 1 Struts 2     Action ...
  • Struts1和Struts2 的一些对比

    千次阅读 热门讨论 2015-03-31 21:48:00
    上篇博客,用图解释了Struts1和Struts2的运行区别,这篇博客将具体对比一下它们的区别。  一、Action方向  前台方向有这么几点:表达语言,Action类,servlet  1、Action 类  Struts1要求Action类继承一...
  • Struts1和Struts2的比较

    千次阅读 2013-02-27 19:02:28
    Struts1和Struts2都是MVC设计模式的经典应用框架,下文从代码,性能,测试,功能等方面对Struts1和Struts2进行简单比较,来看看Struts的高级版本在哪些方面进行了优化。  (1)Action 类:  • Struts1要求...
  • struts 2和struts 1区别

    千次阅读 2011-04-14 17:12:00
     Sruts2从本质上来看源于Webwork,它同时具有Struts和Webwork的优点,并且使用了java1.5的注释为程序员提供了另外一种配置方案,虽然Struts2有许多优点,但它在使用上和Struts1.x有很大的不同。因此,要想从...
  • Struts1与Struts2比较(完整版)

    千次阅读 2014-10-12 11:16:35
    对于struts1和struts2都已经用它们开发过项目多少对它们都有所了解,因此有必要放到一起对比对比它们的异同,也为更深入的学习他们做好铺垫,从目前公司里面使用的情况来看,struts2使用的要更广泛一些。  如果...
  • 从各方面比较Struts2与Struts1之间的区别。 1、Action 类:  Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。  Struts2 Action类可以实现一个Action接口,也...
  • 估计在学过Struts1的人,在学Struts2时,心中都会有一个疑虑.我们有了Struts1为什么还需要Struts2呢?它怎么就能替代Struts1呢?Struts1不是已经很经典了吗? 下面我们就来了解一下到底Struts2带给了我们什么样的惊喜!...
  • Struts1标签库如何升级到Struts2

    千次阅读 2015-01-17 22:43:40
    struts1的struts-logic.tld struts-bean.tld struts-html.tld struts-nested.tld 集成在IDE里。导入struts1.就会有了如果升级到Struts2,先把struts2的jar包导入,只用在jsp头文件加上就能使用struts2.0的标签库
  • Struts1 VS Struts2

    千次阅读 2007-09-23 00:05:00
    序号 对比方面 Struts1 Struts2
  • Struts1是第一个广泛流行的mvc框架,使用及其广泛。但是,随着技术的发展,尤其是JSF、ajax等技术的兴起,struts1有点跟不上时代的步伐,以及他自己在设计上的一些硬伤,阻碍了他的发展。  同时,大量新的mvc框架...
  • struts1 和struts 2区别

    千次阅读 2011-11-04 14:31:43
    Struts1:ActionServlet[process()], RequestProcessor[processPreprocess()], PlugIn, Action,ActionForm,ActionForward,ActionMapping,struts-config.xml; Struts2:FilterDispatcher,ActionSupport,...
  • struts1 在web.xml中的配置: (1)配置Struts的ActionServlet   元素来声明ActionServlet  元素:用来定义Servlet的名称  元素:用来指定Servlet的完整类名  action org.apache.struts.action....
  • Struts2与Struts1的比较

    千次阅读 2012-09-16 15:59:55
    Struts2其实并不是一个陌生的Web框架,Struts2是以Webwork的设计思想为核心,吸收了Struts1的优点,因此,可以认为Struts2是Struts1和Webwork结合的产物。 简单来说二者的区别是:   一个是Stuts1 ,一个是...
  • struts的理解(struts1和struts2的区别)

    千次阅读 2012-06-23 07:58:53
    struts是一种MVC架构的web层处理框架,struts1和struts2有些差别,不过根本原理是一样的。都是通过struts的核心类来处理web页面的请求,将请求分发到不同的action进行处理,并将结果返回给web客户端。 1、Struts1的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,484
精华内容 28,193
关键字:

struts1