structs _生活经验

spring和hibernate有什么区别？分别都是干什么的？hibernate 是一个数据持久层的框架,只管怎么去访问及操作数据库的数据.
spring 是一个更加强大的框架,是为J2EE 应用程序开发提供集成的框架,体现在其简单性、可测试性和松耦合上,同时对面向切面编程也有支撑的.

再简单打个比方,
hibernate 是仓库的仓储管理人员,负责货物的仓储管理.
spring 就是管理层的核心领导,负责协调调度,以保障企业的良好运作.

structs spring hibernate 三者之间有什么关系hibernate用于数据库持久化操作 struts用于拦截器和控制器管理而spring担任中间调度者，相当于经理在后面操作提供一些需要准备的东西简化操作

struts2 hibernate spring 三大框架有什么区别，他们各自适用的范围是什么？各自适用的场合是什么？说struts2是控制层是错误的，因为struts2本身就是一个标准的Web层的MVC框架，主要控制的是"用户的请求——程序的处理——程序的返回"这个流转过程。

hibernate是一个持久层的框架，他在JDBC上进行的轻量级的封装，是用户可以直接用面向对象的方式来操作关系型数据库。例如，如果你想保存一个学生信息，以前可能需要写一个insert语句，用了hibernate就只用调用它的save方法就行了。
spring是一个多元化的框架，它有类似struts的MVC 。但是他最主要的功能是依赖注入和面向切面编程。所谓依赖注入就是说以前你需要一个对象的话需要new一个，这样势必造成代码写死到程序中了，这样不利于改动。依赖注入可以把你需要的对象自动生成了给你，这样用起来就很灵活了。AOO就是在程序需要进行统一处理的地方进行处理，但是又不用写死在程序中。

求高手解答， SSH集成开发中，struts2 , spring,hibernate 都各自起着什么作用，还有MVC的作用是什么？MVC模式就是model、view、Controller的简称,解析的自己搜百度的百科。分层一般分为DAO层、Service层、Action层（当然细分的还有他们的*Impl实现），但不是将struts2 , spring,hibernate 硬塞到一个固定层里去。在DAO层，一般会继承HibernateDAOSupport这个类，如果查看这个类的源代码，就知道其实际就是对数据库的操作，所以可以将hibernate认为是数据库的持久化操作，当然也可以自己扩充HibernateDAOSupport这个类，比如要实行分页就得扩充。HibernateDAOSupport主要使用getHibernate这个东西，而这个东西就是Spring的（理论不知道有没有错，有错的请谅解）。在Service层就是依赖注入在DAO层的接口，实现一些逻辑，比如登录、数据的CRUD 。在Action层，就是依赖注入Service层的借口，继承ActionSupport这个类，提供了核心控制部分的实现。每个层都是松耦的，我依赖你的接口，但是不许知道你实现的是什么代码。比如action就得ref到service的，但是它就只ref ， service去ref dao的也一样，不需知道代码是什么，只要知道有这个接口，其接口有这个方法就行。Spring不是具体一个层应用的，它就是个磨合器，很多框架都能通过它与其他框架整合，但是其自身也有一个MVC的框架。用SSH2的话，一般要配置的文件有web.xml、applicationContext.xml、struts.xml这几个XML配置文件，当然你说用注解的就少点。给个例子你：http://zhidao.baidu.com/question/328218373.html

在Java中 Struts、Spring和Hibernate三者有什么区别?。浚浚浚?/h3>三者都是java应用框架。根据不同得项目，所才用各种框架技术的长处来搭建应用开发平台。
一般的
采用Struts为表示层，或叫view 。因为Struts有apache的支持，而且，目前有很多熟悉Struts开发得程序员。
采用Spirng为逻辑层，Spring是一个基于依赖注入的框架，涉及面非常广，并且能够很好的和hibernate整合起来。
采用Hibernate为持久层，来与数据库打交道。

java中的struts是什么？现在java的strtus分为两个版本，而现在strtus应该是第二个版本strtus2 ，
java web中经典SSH框架中的一位！
他是MVC模式中的控制层（控制用户请求后展现的页面等），
struts2的核心就是action 。易于维护，解耦，灵活性更好。

所以他在java web上的地位是很不一般的！

struts和structs,到底什么鸟关系，说的是同一个东西吗？【structs】struts----->就是框架。。。。structs------->英文翻译是结构，和框架没有关系，我刚学框架的时候也弄错了，将struts写成是structs

什么是struts,有什么用Struts只是一个MVC框架（Framework）,用于快速开发Java Web应用。Struts实现的重点在C(Controller)，包括ActionServlet/RequestProcessor和我们定制的Action,也为V(View)提供了一系列定制标签（Custom Tag）。但Struts几乎没有涉及M(Model),所以Struts可以采用JAVA实现的任何形式的商业逻辑。
Spring是一个轻型容器(light-weight container)，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model) 。在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其他流行的Web框架进行集成。
就是说可将两者一起使用，达到将两者自身的特点进行互补。

structs1 和structs2的区别是什么？详细一点谢谢struts1与struts2本质区别 :
1 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的POJO类都可以用作Struts 2的Action 。
2 线程模式方面的对比：Struts 1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts 1 Action能做的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的；Struts 2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。
3 Servlet依赖方面的对比：Struts 1 Action依赖于Servlet API，因为Struts 1 Action的execute方法中有HttpServletRequest和HttpServletResponse方法。Struts 2 Action不再依赖于Servlet API，从而允许Action脱离Web容器运行，从而降低了测试Action的难度。当然，如果Action需要直接访问HttpServletRequest和HttpServletResponse参数，Struts 2 Action仍然可以访问它们。但是，大部分时候，Action都无需直接访问HttpServetRequest和 HttpServletResponse，从而给开发者更多灵活的选择。
4 可测性方面的对比：测试Struts 1 Action的一个主要问题是execute方法依赖于Servlet API ，这使得Action的测试要依赖于Web容器。为了脱离Web容器测试Struts 1的Action，必须借助于第三方扩展：Struts TestCase ，该扩展下包含了系列的Mock对象（模拟了HttpServetRequest和HttpServletResponse对象），从而可以脱离Web容器测试Struts 1的Action类。Struts 2 Action可以通过初始化、设置属性、调用方法来测试。
5 封装请求参数的对比：Struts 1使用ActionForm对象封装用户的请求参数，所有的ActionForm必须继承一个基类：ActionForm 。普通的JavaBean不能用作ActionForm，因此，开发者必须创建大量的ActionForm类封装用户请求参数。虽然Struts 1提供了动态ActionForm来简化ActionForm的开发，但依然需要在配置文件中定义ActionForm；Struts 2直接使用Action 属性来封装用户请求属性，避免了开发者需要大量开发ActionForm类的烦琐，实际上，这些属性还可以是包含子属性的Rich对象类型。如果开发者依然怀念Struts 1 ActionForm的模式，Struts 2提供了ModelDriven模式，可以让开发者使用单独的Model对象来封装用户请求参数，但该Model对象无需继承任何Struts 2基类，是一个POJO ，从而降低了代码污染。
6 表达式语言方面的对比：Struts 1整合了JSTL，因此可以使用JSTL表达式语言。这种表达式语言有基本对象图遍历，但在对集合和索引属性的支持上则功能不强；Struts 2可以使用JSTL，但它整合了一种更强大和灵活的表达式语言：OGNL（Object Graph Notation Language），因此，Struts 2下的表达式语言功能更加强大。
7 绑定值到视图的对比：Struts 1使用标准JSP机制把对象绑定到视图页面；Struts 2使用“ValueStack”技术，使标签库能够访问值，而不需要把对象和视图页面绑定在一起。
8 类型转换的对比：Struts 1 ActionForm 属性通常都是String类型。Struts 1使用Commons-Beanutils进行类型转换，每个类一个转换器，转换器是不可配置的；Struts 2使用OGNL进行类型转换，支持基本数据类型和常用对象之间的转换。
9 数据校验的对比：Struts 1支持在ActionForm重写validate方法中手动校验，或者通过整合Commons alidator框架来完成数据校验。Struts 2支持通过重写validate方法进行校验，也支持整合XWork校验框架进行校验。
10 Action执行控制的对比：Struts 1支持每一个模块对应一个请求处理（即生命周期的概念），但是模块中的所有Action必须共享相同的生命周期。Struts 2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。开发者可以根据需要创建相应堆栈，从而和不同的Action一起使用。

请问spring与struts有什么区别？

文章插图

1、实现机制不同struts2框架是类级别的拦截，每次来了请求就创建一个controller中对应的Action ，然后调用setter getter方法把request中的数据注入。struts2实际上是通过setter getter方法与request打交道的。struts2中，一个Action对象对应一个request上下文。spring3 mvc不同，spring3mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去。在spring3mvc中，一个方法对应一个request上下文，而方法同时又跟一个url对应。spring mvc的入口是servlet，而struts2是filter 。spring mvc会稍微比struts快。2、Request数据共享不同spring3mvc的方法之间基本上独立的，独享request response数据。请求数据通过参数获?。斫峁ü齅odelMap交回给框架，方法之间不共享变量。struts2就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的。这不会影响程序运行，却给编码、读程序时带来麻烦。3、参数传不同struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。4、设计思想上不同struts更加符合oop的编程思想，spring就比较谨慎，在servlet上扩展。5、intercepter的实现机制不同struts有以自己的interceptor机制，spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大，虽然struts的配置能继承，所以论使用上来讲， spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。参考资料：百度百科—struts参考资料：百度百科—spring
struts框架和spring框架都是做什么用的struts 和spring框架都是用来开发JavaEE程序的。
简单来说是因为原始的JavaEE (开发网站 ,前台+后台）十分的臃肿，开发十分费力。业务层，控制层，视图层，数据层，交织在一起，牵一而动全身，耦合很高（改动一个业务，需要改动很多代码）。
Struts 框架是一个MVC框架，它把JavaEE开发中的控制层、视图层、数据层分开了，（解耦合）。多说一句，JavaEE现在流行的框架是SSM,(spring,springMVC,mybatis),springMVC是一个更优的MVC框架。
spring框架，是为了避免硬编码造成的程序耦合，举个例子：如果我们需要调用函数，首先要导包 import ***,new一个对象。这样两个类之间就有了关联。使用spring框架，就不用去new对象了。（怎么调用？需要深度学习了。。）
总结：struts和spring都是为了解耦合，降低耦合度（高内聚，低耦合），从而让JavaEE开发更快，更容易。让程序更容易维护。
个人观点，仅供参考。。。。

Struts框架有什么用1)建立在MVC这种公认的好的模式上的，struts在M,V,C上都有涉及，但它主要是提供一个好的控制器和一套定制的标签库，也就是说它的着力点在C和V上，有mvc的一系列有点，如：结构层次分明，高可重用性，增加了程序的健壮性和可伸缩性，便于开发与设计分工，提供集中统一的权限控制、校验、国际化、日志等。
2)开源项目，并且经受了实战的检验，使其功能越来越强大，体系也日渐完善。
3)与其他技术和框架具有很好的融合性
4)提高了开发速度

Apache Struts是什么?

文章插图

Apache Struts是金属材料；Apache Struts金属在常温下一般都是固体，有金属光泽，大多数为电和热的优良导体，有延展性，密度较大，熔点较高。地球上的金属资源广泛地存在于地壳和海洋中，除少数很不活泼的金属如金、银等有单质形式存在外，其余都以化合物的形式存在。金属在自然界中广泛存在，在生活中应用极为普遍，在现代工业中是非常重要和应用最多的一类物质。扩展资料：由于金属的电子倾向脱离，因此具有良好的导电性，且金属元素在化合物中通常带正价电，但当温度越高时，因为受到了原子核的热震荡阻碍，电阻将会变大。金属分子之间的连结是金属键，因此随意更换位置都可再重新建立连结，这也是金属伸展性良好的原因。在自然界中，绝大多数金属以化合态存在，少数金属例如金、银、铂、铋以游离态存在。金属矿物多数是氧化物及硫化物，其他存在形式有氯化物、硫酸盐、碳酸盐及硅酸盐。
struts框架里面的.do请求具体是什么？web.xml里可以找到的。它是给Struts的ActionServlet配置的截取url的条件模式。只要满足*.do的url请求都会被servlet截取。如你说的情况，说明你的add.jsp页面提交按钮所在的表单form的action一定是是这样的配置吧
action="add.do" 等你理解了Struts就明白具体的意思了。自己体会一下。

才子_辉祝您愉快！

java中Struts1和Struts2有什么区别 ?1、配置文件格式不同
2、struts1有from类和action类，属性封装from类里，在struts2里只有action类，属性封装action类里
3、页面调用是struts1 是*.do struts2 是*.action
我认为struts2要比struts1，简单、方便、快捷。就是用着比struts1好
以上是我开发的体会，下面是我找的资料
主要表现在如下几个方面：
在Action的实现方面：Struts1要求必须统一扩展自Action类，而Struts2中可以是一个普通的POJO 。
线程模型方面：Struts1的Action工作在单例模式，一个Action的实例处理所有的请求。Struts2的Action是一个请求对应一个实例。没有线程安全方面的问题。
Servlet依赖方面：Struts1的Action依赖于Servlet API ，比如Action的execute方法的参数就包括request和response对象。这使程序难于测试。Struts2中的Action不再依赖于Servlet API，有利于测试，并且实现TDD 。
封装请求参数：Struts1中强制使用ActionForm对象封装请求的参数。Struts2可以选择使用POJO类来封装请求的参数，或者直接使用Action的属性。
表达式语言方面：Struts1中整合了EL，但是EL对集合和索引的支持不强，Struts2整合了OGNL（Object Graph NavigationLanguage）。
绑定值到视图技术：Struts1使用标准的JSP，Struts2使用“ValueStack”技术。
类型转换：Struts1中的ActionForm基本使用String类型的属性。Struts2中使用OGNL进行转换，可以更方便的使用。
数据校验：Struts1中支持覆盖validate方法或者使用Validator框架。Struts2支持重写validate方法或者使用XWork的验证框架。
Action执行控制的对比：Struts1支持每一个模块对应一个请求处理，但是模块中的所有Action必须共享相同的生命周期。Struts2支持通过拦截器堆栈为每一个Action创建不同的生命周期。

struts1和struts2的区别？？

文章插图

一、主体不同1、struts1：是Apache软件基金会（ASF）赞助的一个开源项目。它最初是Jakarta项目中的一个子项目，并在2004年3月成为ASF的顶级项目。2、struts2：Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。二、框架不同1、struts1：通过采用Java Servlet/JSP技术，实现了基于Java EE Web应用的Model-View-Controller（MVC）设计模式的应用框架，是MVC经典设计模式中的一个经典产品。2、struts2：以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。三、Action处理不同1、struts1：Action是单实例的，一个Action的实例处理所有的请求。2、struts2：Struts 2的Action是一个请求对应一个实例（每次请求时都新new出一个对象），没有线程安全方面的问题。参考资料来源：百度百科-struts参考资料来源：百度百科-Struts 2
struts1和struts2的区别1、配置文件格式不同
2、struts1有from类和action类，属性封装from类里，在struts2里只有action类，属性封装action类里
3、页面调用是struts1 是*.dostruts2 是*.action
我认为struts2要比struts1，简单、方便、快捷。就是用着比struts1好
以上是我开发的体会，下面是我找的资料
主要表现在如下几个方面：
在Action的实现方面：Struts1要求必须统一扩展自Action类，而Struts2中可以是一个普通的POJO 。
线程模型方面：Struts1的Action工作在单例模式，一个Action的实例处理所有的请求。Struts2的Action是一个请求对应一个实例。没有线程安全方面的问题。
Servlet依赖方面：Struts1的Action依赖于Servlet API，比如Action的execute方法的参数就包括request和response对象。这使程序难于测试。Struts2中的Action不再依赖于Servlet API，有利于测试，并且实现TDD 。
封装请求参数：Struts1中强制使用ActionForm对象封装请求的参数。Struts2可以选择使用POJO类来封装请求的参数，或者直接使用Action的属性。
表达式语言方面：Struts1中整合了EL，但是EL对集合和索引的支持不强， Struts2整合了OGNL（Object Graph NavigationLanguage）。
绑定值到视图技术：Struts1使用标准的JSP ， Struts2使用“ValueStack”技术。
类型转换：Struts1中的ActionForm基本使用String类型的属性。Struts2中使用OGNL进行转换，可以更方便的使用。
数据校验：Struts1中支持覆盖validate方法或者使用Validator框架。Struts2支持重写validate方法或者使用XWork的验证框架。
Action执行控制的对比：Struts1支持每一个模块对应一个请求处理，但是模块中的所有Action必须共享相同的生命周期。Struts2支持通过拦截器堆栈为每一个Action创建不同的生命周期。

SSH框架中使用structs1和struct2的区别是什么？不可以

首先：struts1是通过servlet启动的。

一、struts1要求Action类继承一个抽象基类，而不是接口。

struts2的action类可以实现一个action接口，也可以实现其他接口。

二、sturts1 action是单例模式，线程是不安全的。

struts2 action线程是安全的，action为每一个请求都生成了一个实例。

三、sturts1过去依赖serlet API，不容易测试。

struts2不依赖于容器，允许Action脱离容器单独被测试。

四、Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。

Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。

五、Struts1 整合了JSTL，因此使用JSTL EL 。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。

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

六、Struts 1使用标准JSP机制把对象绑定到页面中来访问。

Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。

七、Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。

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

八、Struts 1支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。

Struts2支持通过validate方法和XWork校验框架来进行校验。

九、Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。

Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。http://www.linuxso.com/architecture/7694.html

十.执行流程
a)struts1
jsp发起httprequest请求->servlet捕获->struts.xml->namespace+ActionName-> Action->填充表单setXxx()->action.execute()->”success”->Result->设置request属性->跳转目标页b) Action(jsp发起httprequest请求，被过滤器捕获)->FilterDispatcher->struts.xml->namespace+ActionName->new Action->填充表单setXxx()->action.execute()->”success”->Result->设置request属性->跳转目标页

spring 框架与struts框架有什么区别这个区别多了去了。
1个人理解struts就是一个控制器，好比sevlet 。页面访问它，它调用数据接口，加工数据，然后把数据库返回给一个页面.
2spring是ioc容器，说白了就是你用了它，你代码里面再也不需要new Object()方式新建对象了。你在里面配置一个类的路径，当你需要的时候通过反射可以直接获取到该类的一个实例。这种方式能够减少程序之间的耦合。其次spring 包含了springmvc基本能取代struts.当然spring还有其他很多功能，事务控制，aop，安全管理等等。
spring的产生是对以前javaee ejb的一个改进。是不是觉得spring很简单，简简单单那配置实现很多复杂的功能。你去百度spring的核心思想，它为何而生，能解决什么问题。就一目了然了。

struts 和spring 有什么区别通常更多的我们对比 SpringMVC与Struts把这张图放在这里，我是想说SpringMVC和Struts2真的是不一样的，虽然在都有着核心分发器等相同的功能组件（这些由MVC模式本身决定的）。为什么SpringMVC会赢得最后的胜利呢？谈几点我自己的看法：第一、MVC框架的出现是为了将URL从HTTP的世界中映射到JAVA世界中，这是MVC框架的核心功能。而在URL这一点SpringMVC无疑更加优雅。第二、从设计实现角度来说，我觉得SpringMVC更加清晰。即使我们去对比Struts2的原理图和SpringMVC的类图，它依然很让人困惑，远没有SpringMVC更加直观：SpringMVC设计思路：将整个处理流程规范化，并把每一个处理步骤分派到不同的组件中进行处理。这个方案实际上涉及到两个方面：l 处理流程规范化 —— 将处理流程划分为若干个步骤（任务），并使用一条明确的逻辑主线将所有的步骤串联起来l 处理流程组件化 —— 将处理流程中的每一个步骤（任务）都定义为接口，并为每个接口赋予不同的实现模式处理流程规范化是目的，对于处理过程的步骤划分和流程定义则是手段。因而处理流程规范化的首要内容就是考虑一个通用的Servlet响应程序大致应该包含的逻辑步骤：l 步骤1—— 对Http请求进行初步处理，查找与之对应的Controller处理类（方法）——HandlerMappingl 步骤2—— 调用相应的Controller处理类（方法）完成业务逻辑——HandlerAdapterl 步骤3—— 对Controller处理类（方法）调用时可能发生的异常进行处理——HandlerExceptionResolverl 步骤4—— 根据Controller处理类（方法）的调用结果，进行Http响应处理——ViewResolver正是这基于组件、接口的设计，支持了SpringMVC的另一个特性：行为的可扩展性。第三、设计原则更加明朗。【Open for extension /closed for modification】这条重要的设计原则被写在了Spring官方的reference中SpringMVC章节的起始段： A key design principle in SpringWeb MVC and in Spring in general is the “Open for extension, closed for modification” principle.并且重点很好地体现在SpringMVC的实现当中，可以扩展，但却不能改变。我曾经扩展过Spring的IOC、AOP功能，这一点SpringMVC应该和Spring一脉相承。第四、组件化的设计方案和特定的设计原则让SpringMVC形散神聚。神 —— SpringMVC总是沿着一条固定的逻辑主线运行形 —— SpringMVC却拥有多种不同的行为模式SpringMVC是一个基于组件的开发框架，组件的不同实现体系构成了“形”；组件的逻辑串联构成了“神” 。因此，“形散神不散”： SpringMVC的逻辑主线始终不变，而行为模式却可以多种多样。第五、更加贴合Web发展的趋势，这个更加虚了，不再展开说这个问题了。第六、技术上的放缓导致了程序员对Struts2失去了热情，导致SpringMVC依靠自身的努力和Spring的口碑，逐渐显露了自身的优势和特点。为什么SpringMVC会赢得最后的胜利呢？最后，我们不妨想一想Struts2是怎样流行起来的！我自己是从Struts1用过来的，后来Struts1的问题很明显了，开源社区出现了很多的MVC框架，最为突出的是Webwork2 。Webwork2探索了一条与传统Servlet模型不同的解决方案，逐渐被大家熟识和理解，不断发展并得到了广大程序员的认可。它以优秀的设计思想和灵活的实现，吸引了大批的Web层开发人员投入它的怀抱。Apache社区与Opensymphony宣布未来的Struts项目将与Webwork2项目合并，并联合推出Struts2 。Struts2能够在一个相当长的时间段内占据开发市场主导地位的重要原因在于其技术上的领先优势。而这一技术上的领先优势，突出表现为对Controller的彻底改造：public class UserController {private User userpublic String execute() {// 这里加入业务逻辑代码return "success";}} 从上面的代码中，我们可以看到Webwork2 /Struts2对于Controller最大的改造有两点：在Controller中彻底杜绝引入HttpServletRequest或者HttpServletResponse这样的原生Servlet对象。将请求参数和响应数据都从响应方法中剥离到了Controller中的属性变量。这两大改造被看作是框架的神来之笔。因为通过这一改造，整个Controller类彻底与Web容器解耦，可以方便地进行单元测试。而摆脱了Servlet束缚的Controller，也为整个编程模型赋予了全新的定义。从引入新的编程元素的角度来说， Webwork2 / Struts2无疑也是成功的。因为在传统Servlet模式中的禁地Controller中的属性变量被合理利用了起来作为请求处理过程中的数据部分。这样的改造不仅使得表达式引擎能够得到最大限度的发挥，同时使得整个Controller看起来更像是一个POJO 。因而，这种表现形态被笔者冠以的名称是：POJO实现模式。POJO实现模式是一种具有革命性意义的模式，因为它能够把解耦合这样一个观点发挥到极致。从面向对象的角度来看，POJO模式无疑也是所有程序员所追求的一个目标。这也就是Webwork2 /Struts2那么多年来经久不衰的一个重要原因。所以，我们看到第一条原因是Struts2依靠技术上的革新赢得了程序员的青睐。但是，这些年来Struts2在技术革新上的作为似乎步子就迈得比较小。我们可以看到，在JDK1.5普及之后，Annotation作为一种新兴的Java语法，逐渐被大家熟知和应用。这一点上SpringMVC紧跟了时代的潮流，直接用于请求-响应的映射。而Struts2却迟迟无法在单一配置源的问题上形成突破。当然，这只是技术革新上的一个简单的例子，其他的例子还有很多。至少给人的感觉是这样的。在这一点上Struts并不是很沾光，因为Spring的口碑和影响力也客观程度上加深了大家对SpirngMVC是技术领导者的印象。
struts和spring的区别一、Struts
Struts是Apache软件基金下Jakarta项目的一部分。Struts框架的主要架构设计和开发者是Craig R.McClanahan 。Struts是目前Java Web

MVC框架中不争的王者。经过长达五年的发展，Struts已经逐渐成长为一个稳定、成熟的框架，并且占有了MVC框架中最大的市场份额。但是
Struts某些技术特性上已经落后于新兴的MVC框架(这里说的Struts指的是1.0的版本，现在她已经发布了最新的2.0不版本) 。面对
Spring MVC、Webwork2
这些设计更精密，扩展性更强的框架，Struts受到了前所未有的挑战。但站在产品开发的角度而言，Struts仍然是最稳妥的选择。

Struts有一组相互协作的类（组件）、Serlvet以及jsp tag
lib组成。基于struts构架的web应用程序基本上符合JSP
Model2的设计标准，可以说是MVC设计模式的一种变化类型。根据上面对framework的描述，我们很容易理解为什么说Struts是一个web
framwork，而不仅仅是一些标记库的组合。但 Struts
也包含了丰富的标记库和独立于该框架工作的实用程序类。Struts有其自己的控制器（Controller），同时整合了其他的一些技术去实现模型层
（Model）和视图层（View）。在模型层，Struts可以很容易的与数据访问技术相结合，包括EJB,JDBC和Object Relation
Bridge 。在视图层， Struts能够与JSP, Velocity Templates,XSL等等这些表示层组件想结合。
Struts的体系结构

struts framework是MVC
模式的体现，下面我们就从分别从模型、视图、控制来看看struts的体系结构（Architecture）。从视图角度（View）
主要由JSP建立（也可以用别的,如Freemaker），struts自身包含了一组可扩展的自定义标签库（TagLib），可以简化创建用户界面的过
程。目前包括：Bean Tags，HTML Tags ， Logic Tags ， Nested Tags，Template
Tags这几个Taglib 。有关它们的详细资料请参考struts用户手册。

从模型角度（Model）
模型主要是表示一个系统的状态（有时候，改变系统状态的业务逻辑操作也划分到模型中）。在Struts中，系统的状态主要有ActiomForm
Bean体现，一般情况下，这些状态是非持久性的。如果需要将这些状态转化为持久性数据存储，Struts本身也提供了Utitle包，可以方便的与数据
库操作。
从控制器角度（Controller）在Struts
framework中， Controller主要是ActionServlet，但是对于业务逻辑的操作则主要由Action、
ActionMapping、ActionForward这几个组件协调完成（也许这几个组件，应该划分到模型中的业务逻辑一块）。其中，Action扮
演了真正的业务逻辑的实现者，而ActionMapping和ActionForward则指定了不同业务逻辑或流程的运行方向。对于Struts
如何控制、处理客户请求，让我们通过对struts的四个核心组件介绍来具体说明。这几个组件就是：ActionServlet 。Action
Classes，Action Mapping（此处包括ActionForward），ActionFrom Bean 。

二、Spring

Spring实际上是《Expert One-on-One J2EE Design and
Development》一书中所阐述的设计思想的具体实现。在One-on-One一书中，Rod Johnson 倡导J2EE
实用主义的设计思想，并随书提供了一个初步的开发框架实现（interface21 开发包）。而Spring
正是这一思想的更全面和具体的体现。Rod Johnson在interface21
开发包的基础之上，进行了进一步的改造和扩充，使其发展为一个更加开放、清晰、全面、高效的开发框架。

　Spring是一个开源框架，由Rod
Johnson创建并且在他的著作《J2EE设计开发编程指南》里进行了描述。它是为了解决企业应用开发的复杂性而创建的。Spring使使用基本的
JavaBeans来完成以前只可能由EJB完成的事情变得可能了。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度
而言，任何Java应用都可以从Spring中受益。
简单来说，Spring是一个轻量的控制反转和面向切面的容器框架。当然，这个描述有点过于简单。但它的确概括出了Spring是做什么的。为了更好
地理解Spring，让我们分析一下这个描述：
1、轻量

　从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的
处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于轻量，从大小与开销两方面而言Spring都是轻量
的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外， Spring是非侵入
式的：典型地， Spring应用中的对象不依赖于Spring的特定类。
2、控制反转

　Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，对象被动地传递它们的依赖而不是自己创建或者查找依赖对象。你可以认为IoC与JNDI相反??不是对象从容器中查找依赖，而是容器在对象初始化时不等被请求就将依赖传递给它。
　3、面向切面

　Spring包含对面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统服务（例如审计与事物管理）进行内聚性的开发。应用对象只做它们应该做的，完成业务逻辑，仅此而已。它们并不负责（甚至是意识）其它的系统关注点，例如日志或事物支持。
　4、容器
　Spring包含和管理应用对象的配置和生命周期，在这个意义上它是一种容器。你可以配置你的每个bean如何被创建?基于一个配置原形为你的
bean创建一个单独的实例或者每次需要时都生成一个新的实例以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量的EJB容器，它们
经常是庞大与笨重的，难以使用。
框架：Spring是由简单的组件配置和组合复杂的应用成为可能。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。
Spring也提供了很多基础功能（事务管理、持久性框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种子框架提供了基础。

Struts和spring分别是什么?通常更多的我们对比 SpringMVC与Struts把这张图放在这里，我是想说SpringMVC和Struts2真的是不一样的，虽然在都有着核心分发器等相同的功能组件（这些由MVC模式本身决定的）。为什么SpringMVC会赢得最后的胜利呢？谈几点我自己的看法：第一、MVC框架的出现是为了将URL从HTTP的世界中映射到JAVA世界中，这是MVC框架的核心功能。而在URL这一点SpringMVC无疑更加优雅。第二、从设计实现角度来说，我觉得SpringMVC更加清晰。即使我们去对比Struts2的原理图和SpringMVC的类图，它依然很让人困惑，远没有SpringMVC更加直观：SpringMVC设计思路：将整个处理流程规范化，并把每一个处理步骤分派到不同的组件中进行处理。这个方案实际上涉及到两个方面：l 处理流程规范化 —— 将处理流程划分为若干个步骤（任务），并使用一条明确的逻辑主线将所有的步骤串联起来l 处理流程组件化 —— 将处理流程中的每一个步骤（任务）都定义为接口，并为每个接口赋予不同的实现模式处理流程规范化是目的，对于处理过程的步骤划分和流程定义则是手段。因而处理流程规范化的首要内容就是考虑一个通用的Servlet响应程序大致应该包含的逻辑步骤：l 步骤1—— 对Http请求进行初步处理，查找与之对应的Controller处理类（方法）——HandlerMappingl 步骤2—— 调用相应的Controller处理类（方法）完成业务逻辑——HandlerAdapterl 步骤3—— 对Controller处理类（方法）调用时可能发生的异常进行处理——HandlerExceptionResolverl 步骤4—— 根据Controller处理类（方法）的调用结果，进行Http响应处理——ViewResolver正是这基于组件、接口的设计，支持了SpringMVC的另一个特性：行为的可扩展性。第三、设计原则更加明朗。【Open for extension /closed for modification】这条重要的设计原则被写在了Spring官方的reference中SpringMVC章节的起始段： A key design principle in SpringWeb MVC and in Spring in general is the “Open for extension, closed for modification” principle.并且重点很好地体现在SpringMVC的实现当中，可以扩展，但却不能改变。我曾经扩展过Spring的IOC、AOP功能，这一点SpringMVC应该和Spring一脉相承。第四、组件化的设计方案和特定的设计原则让SpringMVC形散神聚。神 —— SpringMVC总是沿着一条固定的逻辑主线运行形 —— SpringMVC却拥有多种不同的行为模式SpringMVC是一个基于组件的开发框架，组件的不同实现体系构成了“形”；组件的逻辑串联构成了“神” 。因此，“形散神不散”： SpringMVC的逻辑主线始终不变，而行为模式却可以多种多样。第五、更加贴合Web发展的趋势，这个更加虚了，不再展开说这个问题了。第六、技术上的放缓导致了程序员对Struts2失去了热情，导致SpringMVC依靠自身的努力和Spring的口碑，逐渐显露了自身的优势和特点。为什么SpringMVC会赢得最后的胜利呢？最后，我们不妨想一想Struts2是怎样流行起来的！我自己是从Struts1用过来的，后来Struts1的问题很明显了，开源社区出现了很多的MVC框架，最为突出的是Webwork2 。Webwork2探索了一条与传统Servlet模型不同的解决方案，逐渐被大家熟识和理解，不断发展并得到了广大程序员的认可。它以优秀的设计思想和灵活的实现，吸引了大批的Web层开发人员投入它的怀抱。Apache社区与Opensymphony宣布未来的Struts项目将与Webwork2项目合并，并联合推出Struts2 。Struts2能够在一个相当长的时间段内占据开发市场主导地位的重要原因在于其技术上的领先优势。而这一技术上的领先优势，突出表现为对Controller的彻底改造：public class UserController {private User userpublic String execute() {// 这里加入业务逻辑代码return "success";}} 从上面的代码中，我们可以看到Webwork2 /Struts2对于Controller最大的改造有两点：在Controller中彻底杜绝引入HttpServletRequest或者HttpServletResponse这样的原生Servlet对象。将请求参数和响应数据都从响应方法中剥离到了Controller中的属性变量。这两大改造被看作是框架的神来之笔。因为通过这一改造，整个Controller类彻底与Web容器解耦，可以方便地进行单元测试。而摆脱了Servlet束缚的Controller，也为整个编程模型赋予了全新的定义。从引入新的编程元素的角度来说，Webwork2 / Struts2无疑也是成功的。因为在传统Servlet模式中的禁地Controller中的属性变量被合理利用了起来作为请求处理过程中的数据部分。这样的改造不仅使得表达式引擎能够得到最大限度的发挥，同时使得整个Controller看起来更像是一个POJO 。因而，这种表现形态被笔者冠以的名称是：POJO实现模式。POJO实现模式是一种具有革命性意义的模式，因为它能够把解耦合这样一个观点发挥到极致。从面向对象的角度来看， POJO模式无疑也是所有程序员所追求的一个目标。这也就是Webwork2 /Struts2那么多年来经久不衰的一个重要原因。所以，我们看到第一条原因是Struts2依靠技术上的革新赢得了程序员的青睐。但是，这些年来Struts2在技术革新上的作为似乎步子就迈得比较小。我们可以看到，在JDK1.5普及之后，Annotation作为一种新兴的Java语法，逐渐被大家熟知和应用。这一点上SpringMVC紧跟了时代的潮流，直接用于请求-响应的映射。而Struts2却迟迟无法在单一配置源的问题上形成突破。当然，这只是技术革新上的一个简单的例子，其他的例子还有很多。至少给人的感觉是这样的。在这一点上Struts并不是很沾光，因为Spring的口碑和影响力也客观程度上加深了大家对SpirngMVC是技术领导者的印象。
struts2和springmvc有什么区别从Struts2的发展过程来看，Struts2继承了Struts与WebWork的血脉，Struts2取两者之精华，形成新德框架，但是struts2还是更多的继承了struts的设计思想，并加入了WebWork的优点。在了解Struts2体系之前，让我们先看看struts2对struts做了哪些修改。
Struts2与struts的不同主要体现在以下几个方面。
（1）Action类

1》在struts中都是使用抽象类编程而不是接口，因此他要求开发Action类继承一个抽象的基类，如DispatchAction等。

2》Struts2则基于接口编程，我们的Action类可以实现一个Action接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。更加强大的是，在struts2中Action接口不是必需的，任何有execute()函数的pojo对象都可以用作struts2的Action类来使用。

（2）线程模式

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

2》struts2的Action对象为每一个请求产生一个实例，因此没有线程安全问题。

（3）Servlet依赖

1》struts的Action依赖于Servlet API，当一个Action被调用时，HttpServletRequest和HttpServletResponse被传递给执行方法，例如：

publicActionForward execute(Actionmapping mapping,ActionForm Form,HttpServletRequestrequest,HttpServletResponse response){

}

2》struts2的Action不依赖与容器，允许Action脱离容器单独被测试。如果需要， Struts2的Action任然可以访问初始的request和response 。例如下面的这个类MyAction.Java，他可以通过ActionContext对象取得Session值，也可以通过ServletActionContext对象取得request对象。

Publicclass MyAction{
protected Object getSession(String key){
return ActionContext.getContext().getSession(key);
}
protectedHttpServletRequest getRequest(){
return(String)ServletActionContext.getRequest();
}
}

（4）可测试性

1》测试Struts Action的一个主要问题是，execute（）方法暴露了Servlet API，这使得测试要依赖于容器。虽然有第三方的软件struts TestCase能够使用模拟对象来进行测试，但显然会让我们的测试变得更加复杂。

2》Struts2 Action的类是POJO对象，因此可以直接编写测试类来测试Action类，只需要在测试类中注入属性即可。

（5）捕获输入

1》struts使用ActionForm对象捕获用户输入，所有的ActionForm必须继承一个基类ActionForm 。因为其他的JavaBean不能用作ActionForm ，开发者经常创建多余的类捕获输入。动态表单可以作为创建传统ActionForm的选择，但是，开发者可能是再创建已经存在的JavaBean，仍然会导致有冗余的JavaBean；

2》struts2直接使用Action属性作为输入属性，消除对第二个输入对象的需求。输入属性可能是有自己子属性的rich对象类型。Action属性能够通过Web页面的taglibs访问。同时， struts2也支持ActionForm模式。

（6）表达式语言

1》struts整合了JSTL，这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱

2》struts2可以使用JSTL ，但是也支持一个更强大和灵活的表达式语言OGNL

（7）绑定值到页面

1》struts使用标准jsp机制把对象绑定到页面中来访问

2》struts2使用ValueStack（值堆栈）技术，使taglib能够访问值，而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）

（8）类型转换

1》struts的ActionForm属性通常都是String类型，并不使用 Commons-Beanutils进行类型转换。每个类提供一个转换器，对每个实例来说是不可配置的；

2》struts2使用OGNL进行OGNL进行类型转换，提供了基本和常用对象转换器。

（9）数据校验

1》struts支持在ActionForm的Validate方法中手动校验，或者通过Commons Validator来扩展校验。同一个类可以有不同的校验内容，但不能校验子对象；

2》struts2支持通过validata（）方法和XWork校验框架来进行校验， XWork校验框架使用为属性类型定义的校验和内容校验，来支持chain校验子属性。

（10） Action执行的控制

1》struts支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须提供相同的生命周期；

2》struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期，堆栈能够根据需要和不同的Action一起使用

Spring MVC和Struts2的区别spring3mvc与struts2比较
项目刚刚换了web层框架，放弃了struts2改用spring3mvc
当初还框架的时候目的比较单纯---springmvc支持rest，小生对restful url由衷的喜欢
不用不知道一用就发现开发效率确实比struts2高

我们用struts2时采用的传统的配置文件的方式，并没有使用传说中的0配置
spring3 mvc可以认为已经100%零配置了（除了配置springmvc-servlet.xml外）

比较了一下strus2与spring3 mvc的差别

============================================
struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入
struts2实际上是通过setter getter方法与request打交道的
struts2中，一个Action对象对应一个request上下文

spring3 mvc不同， spring3mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去
在spring3mvc中，一个方法对应一个request上下文

好了我们来整理一下
struts2是类级别的拦截，一个类对应一个request上下文，
springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应
所以说从架构本身上 spring3 mvc就容易实现restful url
而struts2的架构实现起来要费劲
因为struts2 action的一个方法可以对应一个url
而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了

===================================
spring3mvc的方法之间基本上独立的，独享request response数据
请求数据通过参数获取，处理结果通过ModelMap交回给框架
方法之间不共享变量

而struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的
这不会影响程序运行，却给我们编码读程序时带来麻烦

====================================
spring3 mvc的验证也是一个亮点，支持JSR303
处理ajax的请求更是方便只需一个注解@ResponseBody ，然后直接返回响应文本即可

附上一段代码
Java代码
@RequestMapping(value=https://www.zaoxu.com/jjsh/bkdq/"/whitelists")
public String index(ModelMap map){
Account account = accountManager.getByDigitId(SecurityContextHolder.get().getDigitId()) ;
List groupList = groupManager.findAllGroup(account.getId()) ;
map.put("account", account);
map.put("groupList", groupList);
return "/group/group-index" ;
}
//@ResponseBody ajax响应
@RequestMapping(value=https://www.zaoxu.com/jjsh/bkdq/"/whitelist/{whiteListId}/del")
@ResponseBody
public String delete(@PathVariable Integer whiteListId){
whiteListManager.deleteWhiteList(whiteListId) ;
return "success" ;
}

spring和struts的区别1、Struts2是类级别的拦截，一个类对应一个request上下文， SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful
url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url ，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。

2、由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码
读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。

4、拦截器实现机制上，Struts2有以自己的interceptor机制， SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。

5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。

6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。

7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。

8、Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。

9、设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。
10、SpringMVC开发效率和性能高于Struts2 。
11、SpringMVC可以认为已经100%零配置

简述Springmvc对于struts的优势?1、Struts2是类级别的拦截，一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url ，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。2、由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获?。斫峁ü齅odelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。4、拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。6、SpringMVC集成了Ajax ，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。8、Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。9、设计思想上，Struts2更加符合OOP的编程思想，SpringMVC就比较谨慎，在servlet上扩展。10、SpringMVC开发效率和性能高于Struts2 。11、SpringMVC可以认为已经100%零配置。
struts相比于springmvc有优势吗struts2相比spring mvc：

1.使用struts2完全感知不到控制层的存在，实现对控制层的解耦。

2.struts2 使用filter做入口，相比spring mvc/struts1使用servlet做入口，更轻量级，体量更小

3.易用性， struts2使用ModelDriven，可以大大简化代码的开发，struts会自动帮你找到action,以及action中的方法，说struts2难用只能说你不会用。

4.性能，值栈的使用会有那么大的性能损耗？

5.struts1/spring mvc都是使用servlet做入口，难道struts1性能会比spring软件开发www.xiupin365.net?mvcstruts1内部实现就一个模板模式而已。为什么还要struts2 ？

6.struts2在思想上、设计上要比spring mvc更先进，更高层。spring mvc 跟 struts1是一个层级的东西。

springmvc和struts2的机制各有什么利弊把这张图放在这里，我是想说SpringMVC和Struts2真的是不一样的，虽然在都有着核心分发器等相同的功能组件（这些由MVC模式本身决定的）。为什么SpringMVC会赢得最后的胜利呢？谈几点我自己的看法：第一、MVC框架的出现是为了将URL从HTTP的世界中映射到JAVA世界中，这是MVC框架的核心功能。而在URL这一点SpringMVC无疑更加优雅。第二、从设计实现角度来说，我觉得SpringMVC更加清晰。即使我们去对比Struts2的原理图和SpringMVC的类图，它依然很让人困惑，远没有SpringMVC更加直观：SpringMVC设计思路：将整个处理流程规范化，并把每一个处理步骤分派到不同的组件中进行处理。这个方案实际上涉及到两个方面：l 处理流程规范化 —— 将处理流程划分为若干个步骤（任务），并使用一条明确的逻辑主线将所有的步骤串联起来l 处理流程组件化 —— 将处理流程中的每一个步骤（任务）都定义为接口，并为每个接口赋予不同的实现模式处理流程规范化是目的，对于处理过程的步骤划分和流程定义则是手段。因而处理流程规范化的首要内容就是考虑一个通用的Servlet响应程序大致应该包含的逻辑步骤：l 步骤1—— 对Http请求进行初步处理，查找与之对应的Controller处理类（方法）——HandlerMappingl 步骤2—— 调用相应的Controller处理类（方法）完成业务逻辑——HandlerAdapterl 步骤3—— 对Controller处理类（方法）调用时可能发生的异常进行处理——HandlerExceptionResolverl 步骤4—— 根据Controller处理类（方法）的调用结果，进行Http响应处理——ViewResolver正是这基于组件、接口的设计，支持了SpringMVC的另一个特性：行为的可扩展性。第三、设计原则更加明朗。【Open for extension /closed for modification】这条重要的设计原则被写在了Spring官方的reference中SpringMVC章节的起始段： A key design principle in SpringWeb MVC and in Spring in general is the “Open for extension, closed for modification” principle.并且重点很好地体现在SpringMVC的实现当中，可以扩展，但却不能改变。我曾经扩展过Spring的IOC、AOP功能，这一点SpringMVC应该和Spring一脉相承。第四、组件化的设计方案和特定的设计原则让SpringMVC形散神聚。神 —— SpringMVC总是沿着一条固定的逻辑主线运行形 —— SpringMVC却拥有多种不同的行为模式SpringMVC是一个基于组件的开发框架，组件的不同实现体系构成了“形”；组件的逻辑串联构成了“神” 。因此，“形散神不散”： SpringMVC的逻辑主线始终不变，而行为模式却可以多种多样。第五、更加贴合Web发展的趋势，这个更加虚了，不再展开说这个问题了。第六、技术上的放缓导致了程序员对Struts2失去了热情，导致SpringMVC依靠自身的努力和Spring的口碑，逐渐显露了自身的优势和特点。为什么SpringMVC会赢得最后的胜利呢？最后，我们不妨想一想Struts2是怎样流行起来的！我自己是从Struts1用过来的，后来Struts1的问题很明显了，开源社区出现了很多的MVC框架，最为突出的是Webwork2 。Webwork2探索了一条与传统Servlet模型不同的解决方案，逐渐被大家熟识和理解，不断发展并得到了广大程序员的认可。它以优秀的设计思想和灵活的实现，吸引了大批的Web层开发人员投入它的怀抱。Apache社区与Opensymphony宣布未来的Struts项目将与Webwork2项目合并，并联合推出Struts2 。Struts2能够在一个相当长的时间段内占据开发市场主导地位的重要原因在于其技术上的领先优势。而这一技术上的领先优势，突出表现为对Controller的彻底改造：public class UserController {private User userpublic String execute() {// 这里加入业务逻辑代码return "success";}}从上面的代码中，我们可以看到Webwork2 /Struts2对于Controller最大的改造有两点：在Controller中彻底杜绝引入HttpServletRequest或者HttpServletResponse这样的原生Servlet对象。将请求参数和响应数据都从响应方法中剥离到了Controller中的属性变量。这两大改造被看作是框架的神来之笔。因为通过这一改造，整个Controller类彻底与Web容器解耦，可以方便地进行单元测试。而摆脱了Servlet束缚的Controller，也为整个编程模型赋予了全新的定义。从引入新的编程元素的角度来说，Webwork2 / Struts2无疑也是成功的。因为在传统Servlet模式中的禁地Controller中的属性变量被合理利用了起来作为请求处理过程中的数据部分。这样的改造不仅使得表达式引擎能够得到最大限度的发挥，同时使得整个Controller看起来更像是一个POJO 。因而，这种表现形态被笔者冠以的名称是：POJO实现模式。POJO实现模式是一种具有革命性意义的模式，因为它能够把解耦合这样一个观点发挥到极致。从面向对象的角度来看，POJO模式无疑也是所有程序员所追求的一个目标。这也就是Webwork2 /Struts2那么多年来经久不衰的一个重要原因。所以，我们看到第一条原因是Struts2依靠技术上的革新赢得了程序员的青睐。但是，这些年来Struts2在技术革新上的作为似乎步子就迈得比较小。我们可以看到，在JDK1.5普及之后，Annotation作为一种新兴的Java语法，逐渐被大家熟知和应用。这一点上SpringMVC紧跟了时代的潮流，直接用于请求-响应的映射。而Struts2却迟迟无法在单一配置源的问题上形成突破。当然，这只是技术革新上的一个简单的例子，其他的例子还有很多。至少给人的感觉是这样的。在这一点上Struts并不是很沾光，因为Spring的口碑和影响力也客观程度上加深了大家对SpirngMVC是技术领导者的印象。
哪位高手说说struts2 与spring mvc 各自的优缺点功能上没啥区别。struts2 比较重量级点。功能强大。spring mvc 更轻量，开发灵活。
萝卜白菜，各有所爱。
性能上来说，还真不是没啥差别。在大并发下， spring mvc 优势很明显。

java中struts的核心思想是什么？struts1里面有个东西叫ActionServelt……（就是一个servlet）你要用的时候不都要配一个ActionServlet到web.xml么……其实就是先用actionservlet接受请求，然后再根据配置来转发

java里面的structs框架、还有什么javabean都是什么？有什么作用？Struts框架是对MVC（模型Model视图View控制器Controller）设计模式的实现，作用是在于接收用户的请求，调用业务逻辑代码。转发到正确的页面。在三层设计模式中实现了控制器的作用。
其实框架的概念很广，它包含了有名的SSH三大框架，也就是Struts、Spring、Hibernate.框架就是一系列的组件，按照一定的结构组合在一起，作为系统开发的平台。使用的框架就是拿别人已经开发好的半成品继续加工自己的业务。就是能让我们能够站在巨人的肩膀上，享用前人经验和智慧。当然框架的好处也是很大的。

JavaBean是一些封装数据和业务逻辑的Java类，它也是为了结合MVC设计模式来定的,JavaBean在其中充当模型的角色

java中struts2是什么意思楼主您好
struts2是java语言编写的一套被广泛应用于web系统的mvc框架

java中struts的核心思想是什么？struts好象是来自建筑业的支持金属框架也就是说struts 是用来支撑作用的
而对于程序相对传统的MVC模式而言
struts 有更好的弹性和可维护性
struts 框架具有组件的模块化，灵活性和重用性的优点，
同时简化了基于MVC的web应用程序的开发

java 中的strutsstruts也是一种框架，目前指struts2 。最早出现的Struts1是一个非常著名的框架，它实现了MVC模式。Struts1简单小巧，其中最成熟的版本是Struts1.2 。之后出现了WebWork框架，其实现技术比Struts1先进，但影响力丌如Struts1 。在框架技术丌断发展过程中，有人在WebWork 核心XWork 的基础上包装了Struts1（算是两种框架的整合），由此，结合了Struts1的影响力和WebWork 的先进技术，Struts 2诞生了。所以说，Struts2丌是Struts1的升级，它更像是WebWork 的升级版本

到底有没有structs这个框架？我只知道struts ，可是网上搜structs得到的很多都是struts 。求高人指点。Java EE中只有Struts框架，很多人误拼为Structs

hibernate怎么实现分页，没用spring和struts,有没有可以直接使用的源码，网上的都不全或者是structs的public List findTaskInstanceHistories(final String appId,
final int taskId){
List taskInstanceHistorys = new ArrayList();
final String hql = "from TaskInstanceHistory t where t.appId=? and t.taskId=?";
taskInstanceHistorys = (List)getMyHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {

return session.createQuery(hql).setParameter(0, appId)
.setParameter(1, taskId).list();
}
});
return taskInstanceHistorys;
}

基于Struts的简单登陆系统（WEB-INF下没有structs-template.tld文件）为什么?。?/h3>可能就是没有，可能你忘记导入进来了？自动生成的话第一种可能性大，报错吗？没有它。

structs是什么struts是一种mvc,从;>;中借来一句话, 送给你, 希望于你对mvc的理解有帮助

对于现有较成熟的Model-View-Control(MVC)框架而言，其解决的主要问题无外乎下
面几部分：
1．将Web页面中的输入元素封装为一个（请求）数据对象。
2．根据请求的不同，调度相应的逻辑处理单元，并将（请求）数据对象作为参数传入。
3．逻辑处理单元完成运算后，返回一个结果数据对象。
4．将结果数据对象中的数据与预先设计的表现层相融合并展现给用户。
各个MVC 实现固然存在差异，但其中的关键流程大致如上。

c语言中，struct怎么用，什么意思？？struct:一种构造数据类型
c语言中?:和!是什么意思,怎么运用在编程中

文章插图

?:的意思是条件运算符，使用的格式如下（条件）？A：B，如果条件成立，表达式的值就是A，否则是B 。！的意思是用来取非运算的，！true的结果就是 false！false 的结果是 true 。写程序中，？：用的比较少，！主要用在条件判断中。比如int a=9 ， b=8；a>b?a=8:b=9；//就是这句相当于if语句，问号前面的表达式为真的时候执行a=8 ，否则b=9 。扩展资料：结合性：C语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左) 。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，再执行+z 的运算。这种自左至右的结合方向就称为“左结合性” 。而自右至左的结合方向称为“右结合性” 。最典型的右结合性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。参考资料来源：百度百科-C语言运算符
C语言里面，%d %c %f 分别是什么意思？怎么用？%d是用来输出十进制整型数据的实际长度输出；%c是以字符形式输出，只输出一个字符；%f是以小数形式输出单、双精度度数，隐含输出6位小数。例子：int a=123;CString temp;// %d是十进制整数(int)temp.Format(“输出：%d”,a);::MessageBox(NULL,temp,"信息",0);信息框会显示123%d是显示10进制的整数，%c是显示单个字符，%f是显示浮点数（可简单的认为是小数的一种） printf("%d %c %f", 5, 'A' , 2.5 )拓展资料这些是格式声明，格式声明由“%”和格式字符组成。常用的格式字符有：1）d格式符，用来输出一个有符号的十进制整数；2）c格式符，用来输出一个字符；3）s格式符，用来输出一个字符串；4）f格式符，用来输出实数；5）e格式符，用格式声明%e指定以指数形式输出实数；6）i格式符，作用跟d格式符一样，不过习惯用%d而少用%i；7）o格式符，以八进制整数形式输出；8）x格式符，以十六进制数形式输出整数。
C语言里面，%d%c%f分别是什么意思？怎么用？%c单个字符

%d十进制整数(int)

%ld十进制整数(long)

%f十进制浮点数(float)

%lf十进制浮点数(double)

%o八进制数

%s字符串(char)

%u无符号十进制数(DWORD)

%x十六进制数(0x00000)

例子：
int a=123;
CString temp;
// %d是十进制整数(int)
temp.Format(“输出：%d”,a);
::MessageBox(NULL,temp,"信息",0);

信息框会显示123

C语言中，struct用什么来定义？struct是一种类型(结构体类型)与int、float一样的，它是为了解决C语言类型单调而设计的。在它里面可以出现int、string类型等C语言类型。使用它不需要定义，常常用它定义结构体。如定义一学生结构体：
struct students
{
int age;
int Number;
char name[20];
}
还可以通过结构体建立C语言的灵魂——链表
如：struct student
{int data；
struct student *next；
}