Struts
是一个为开发基于模型(Model)－视图(View)－控制器(Controller)(MVC)模式的应用架构的开源框架，是利用Java Servlet和JSP构建Web应用的一项非常有用的技术。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，因而吸引了众多的开发人员的关注。
首先事件是指从客户端页面（浏览器）由用户操作触发的事件，Struts使用Action来接受浏览器表单提交的事件，这里使用了Command 模式，每个继承Action的子类都必须实现一个方法execute。
struts重要的表单对象ActionForm是一种对象，它代表了一种应用，这个对象中至少包含几个字段，这些字段是Jsp页面表单中的input字段，因为一个表单对应一个事件，所以，当我们需要将事件粒度细化到表单中这些字段时，也就是说，一个字段对应一个事件时，单纯使用Struts就不太可能，当然通过结合JavaScript也是可以转弯实现的。
Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。
Struts框架可分为以下四个主要部分：
1、模型(Model)，本质上来说在Struts中Model是一个Action类(这个会在后面详细讨论)，开发者通过其实现商业逻辑，同时用户请求通过控制器(Controller)向Action的转发过程是基于由struts-
config.xml文件描述的配置信息的。
2、视图(View)，View是由与控制器Servlet配合工作的一整套JSP定制标签库构成，利用她们我们可以快速建立应用系统的界面。
3、控制器(Controller)，本质上是一个Servlet，将客户端请求转发到相应的Action类。
4、一堆用来做XML文件解析的工具包，Struts是用XML来描述如何自动产生一些JavaBean的属性的，此外Struts还利用XML来描述在国际化应用中的用户提示信息的(这样一来就实现了应用系统的多语言支持)。
Hibernate
Hibernate是一个免费的开源Java包，它使得与关系数据库打交道变得十分轻松，就像您的数据库中包含每天使用的普通Java对象一样，同时不必考虑如何把它们从神秘的数据库表中取出（或放回到数据库表中）。它解放了您，使您可以专注于应用程序的对象和功能，而不必担心如何保存它们或稍后如何找到它们。
大多数应用程序都需要处理数据。Java应用程序运行时，往往把数据封装为相互连接的对象网络，但是当程序结束时，这些对象就会消失在一团逻辑中，所以需要有一些保存它们的方法。有时候，甚至在编写应用程序之前，数据就已经存在了，所以需要有读入它们和将其表示为对象的方法。手动编写代码来执行这些任务不仅单调乏味、易于出错，而且会占用整个应用程序的很大一部分开发工作量。
优秀的面向对象开发人员厌倦了这种重复性的劳动，他们开始采用通常的“积极”偷懒做法，即，创建工具，使整个过程自动化。对于关系数据库来说，这种努力的最大成果就是对象/关系映射(ORM)工具。
这类工具有很多，从昂贵的商业产品到内置于J2EE中的EJB标准。然而，在很多情况下，这些工具具有自身的复杂性，使得开发人员必须学习使用它们的详细规则，并修改组成应用程序的类以满足映射系统的需要。由于这些工具为应付更加严格和复杂的企业需求而不断发展，于是在比较简单和常见的场景中，使用它们所面临的复杂性反而盖过了所能获得的好处。这引起了一场革命，促进了轻量级解决方案的出现，而
Hibernate就是这样的一个例子。
Hibernate的工作方式
Hibernate不会对您造成妨碍，也不会强迫您修改对象的行为方式。它们不需要实现任何不可思议的接口以便能够持续存在。惟一需要做的就是创建一份XML“映射文档”，告诉Hibernate您希望能够保存在数据库中的类，以及它们如何关联到该数据库中的表和列，然后就可以要求它以对象的形式获取数据，或者把对象保存为数据。与其他解决方案相比，它几乎已经很完美了。
由于本文只是一篇介绍性的文章，所以不会引入构建和使用Hibernate映射文档的具体例子（我在《Hibernate: A Developer's Notebook》一书的头几章中已经介绍了一个例子）。此外，在网上和Hibernate的在线文档中，还可以找到一些不错的例子，请参见下面
的“其他信息”部分。它实际上相当直观。应用程序对象中的属性以一种简单而自然的方式与正确的数据库结构相关联。
运行时，Hibernate读取映射文档，然后动态构建Java类，以便管理数据库与Java之间的转换。在Hibernate中有一个简单而直观的API，用于对数据库所表示的对象执行查询。要修改这些对象，（一般情况下）只需在程序中与它们进行交互，然后告诉Hibernate保存修改即可。类似地，创建新对象也很简单；只需以常规方式创建它们，然后告诉Hibernate有关它们的信息，这样就能在数据库中保存它们。
Hibernate API学习起来很简单，而且它与程序流的交互相当自然。在适当的位置调用它，就可以达成目的。它带来了很多自动化和代码节省方面的好处，所以花一点时间学习它是值得的。而且还可以获得另一个好处，即代码不用关心要使用的数据库种类（否则的话甚至必须知道）。我所在的公司就曾有过在开发过程后期被迫更换数据库厂商的经历。这会造成巨大的灾难，但是借助于Hibernate，只需要简单地修改Hibernate配置文件即可。
这里的讨论假定您已经通过创建Hibernate映射文档，建立了一个关系数据库，并且拥有要映射的Java类。有一个Hibernate“工具集”可在编译时使用，以支持不同的工作流。例如，如果您已经拥有Java类和映射文档，Hibernate可以为您创建（或更新）必需的数据库表。或者，仅仅
从映射文档开始，Hibernate也能够生成数据类。或者，它可以反向设计您的数据库和类，从而拟定映射文档。还有一些用于Eclipse的alpha 插件，它们可以在IDE中提供智能的编辑支持以及对这些工具的图形访问。
如果您使用的是Hibernate 2环境，这些工具鲜有提供，但是存在可用的第三方工具。
使用Hibernate的场合
既然Hibernate看起来如此灵活好用，为什么还要使用其他的工具呢？下面有一些场景，可以帮助您做出判断（或许通过提供一些比较和上下文，可以有助于鉴别非常适用Hibernate的场合）。
如果应用对于数据存储的需要十分简单——例如，您只想管理一组用户优先选择——您根本不需要数据库，更不用说一个优秀的对象-关系映射系统了（即使它也如Hibernate这般易于使用）！从Java 1.4开始，有一个标准的Java Preferences API可以很好地发挥这个作用。（在ONJava文章中可以找到有关Preferences API的更多信息。）
对于熟悉使用关系数据库和了解如何执行完美的SQL查询与企业数据库交互的人来说，Hibernate似乎有些碍手碍脚，这就像带有动力和自动排挡的快艇车会使注重性能的赛车驾驶员不耐烦一样。如果您属于这种人，如果您所在的项目团队拥有一个强大的DBA，或者有一些存储过程要处理，您可能想研究一下iBATIS。Hibernate的创建者本身就把iBATIS当作是另一种有趣的选择。我对它很有兴趣，因为我们曾为一个电子商务站点开发了一个类似的系统（其功能更为强大），而且从那时到现在，我们已经在其他环境中使用过它，尽管在发现Hibernate之后，在新项目中我们通常更喜欢使用Hibernate。您可以认为，以SQL为中心的解决方案（比如iBATIS）是“反向的”对象/关系映射工具，而Hibernate是一个更为传统的ORM。
当然，还有其他的外部原因会导致采用另外的方法。比如，在一个企业环境中，必须使用成熟的EJB架构（或者其他的一些非普通对象映射系统）。可以为提供自己的数据存储工具的平台量身定做代码，比如Mac OS X's Core Data。使用的可能是像XML DTD这样的存储规范，而它根本不涉及关系数据库。
但是，如果您使用的是富对象模型，而且想要灵活、轻松且高效地保存它（无论您是否正要开始或已经决定使用关系数据库，只要这是一个选择——而且存在可用的优秀免费数据库，比如MySQL，或可嵌入Java的HSQLDB，它就应该始终是一个选择），那么Hibernate很可能就是您理想的选择。您可能会惊讶于节省的时间之多，以及您将会多么地喜欢使用它。
spring
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring 中受益。
" 目的：解决企业应用开发的复杂性
" 功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能" 范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
■ 轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring 应用中的对象不依赖于Spring的特定类。
■ 控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
■ 面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
■ 容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
■ 框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
在这由三部分组成的介绍 Spring 框架的系列文章的第一期中，将开始学习如何用Spring 技术构建轻量级的、强壮的J2EE 应用程序。developerWorks 的定期投稿人Naveen Balani 通过介绍Spring 框架开始了他由三部分组成的Spring 系列，其中还将介绍Spring 面向方面的编程（AOP）和控制反转（IOC）容器。
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
在这篇由三部分组成的 Spring 系列的第 1 部分中，我将介绍 Spring 框架。我先从框架底层模型的角度描述该框架的功能，然后将讨论两个最有趣的模块：Spring 面向方面编程（AOP）和控制反转（IOC）容器。接着将使用几个示例演示IOC 容器在典型应用程序用例场景中的应用情况。这些示例还将成为本系列后面部分进行的展开式讨论的基础，在
本文的后面部分，将介绍 Spring 框架通过 Spring AOP 实现 AOP 构造的方式。
请参阅下载，下载Spring 框架和Apache Ant，运行本系列的示例应用程序需要它们。
Spring 框架
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理bean 的方式，如图 1 所示。
图 1. Spring 框架的 7 个模块
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了Spring 框架中。所以，可以很容易地使Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个ORM 框架，从而提供了ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于Web 的应用程序提供了上下文。所以，Spring 框架支持与Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建Web 应用程序的
MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。Spring 框架的功能可以用在任何J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同
J2EE 环境（Web 或 EJB）、独立应用程序、测试环境之间重用。
回页首
IOC 和 AOP
控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在Spring 框架中是IOC 容器）负责将这些联系在一起。
在典型的IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了IOC 的一个实现模式。
类型 1 服务需要实现专门的接口，通过接口，由对象提供这些服务，可以从对象查询依赖性（例如，需要的附加服务）
类型 2 通过 JavaBean 的属性（例如 setter 方法）分配依赖性
类型 3 依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开Spring 框架的 IOC 容器采用类型 2 和类型3 实现。
面向方面的编程
面向方面的编程，即AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。
AOP 和IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用Spring AOP 编写的应用程序代码是松
散耦合的。
AOP 的功能完全集成到了Spring 事务管理、日志和其他各种特性的上下文中。
回页首
IOC 容器
Spring 设计的核心是org.springframework.beans 包，它的设计目标是与JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。
BeanFactory 支持两个对象模型。
单态模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
原型模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。
bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样，Spring 框架使用JavaBean 属性和配置数据来指出必须设置的依赖关系。
BeanFactory 接口
因为org.springframework.beans.factory.BeanFactory 是一个简单接口，所以可以针对各种底层存储方法实现。最常用的BeanFactory 定义是XmlBeanFactory，它根据XML 文件中的定义装入bean，如清单 1 所示。
清单 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));
在XML 文件中定义的Bean 是被消极加载的，这意味在需要bean 之
前，bean 本身不会被初始化。要从BeanFactory 检索bean，只需调用getBean() 方法，传入将要检索的 bean 的名称即可，如清单 2 所示。
清单 2. getBean()
MyBean mybean = (MyBean) factory.getBean("mybean");
每个bean 的定义都可以是POJO （用类名和JavaBean 初始化属性定义）或 FactoryBean。FactoryBean 接口为使用 Spring 框架构建的应用程序添加了一个间接的级别。
回页首
IOC 示例
理解控制反转最简单的方式就是看它的实际应用。在对由三部分组成的Spring 系列的第 1 部分进行总结时，我使用了一个示例，演示了如何通过Spring IOC 容器注入应用程序的依赖关系（而不是将它们构建进来）。
我用开启在线信用帐户的用例作为起点。对于该实现，开启信用帐户要求用户与以下服务进行交互：
信用级别评定服务，查询用户的信用历史信息。
远程信息链接服务，插入客户信息，将客户信息与信用卡和银行信息连接起来，以进行自动借记（如果需要的话）。
电子邮件服务，向用户发送有关信用卡状态的电子邮件。
回页首
三个接口
对于这个示例，我假设服务已经存在，理想的情况是用松散耦合的方式把它们集成在一起。以下清单显示了三个服务的应用程序接口。
清单 3. CreditRatingInterface
public interface CreditRatingInterface {
public boolean getUserCreditHistoryInformation(ICustomer iCustomer);
}
清单 3 所示的信用级别评定接口提供了信用历史信息。它需要一个包含客户信息的 Customer 对象。该接口的实现是由 CreditRating 类提供的。清单 4. CreditLinkingInterface
public interface CreditLinkingInterface {
public String getUrl();
public void setUrl(String url);
public void linkCreditBankAccount() throws Exception ;
}
信用链接接口将信用历史信息与银行信息（如果需要的话）连接在一起，并插入用户的信用卡信息。信用链接接口是一个远程服务，它的查询是通过 getUrl() 方法进行的。URL 由 Spring 框架的 bean 配置机制设置，我稍后会讨论它。该接口的实现是由 CreditLinking 类提供的。
清单 5. EmailInterface
public interface EmailInterface {
public void sendEmail(ICustomer iCustomer);
public String getFromEmail();
public void setFromEmail(String fromEmail) ;
public String getPassword();
public void setPassword(String password) ;
public String getSmtpHost() ;
public void setSmtpHost(String smtpHost);
public String getUserId() ;
public void setUserId(String userId);
}
EmailInterface 负责向客户发送关于客户信用卡状态的电子邮件。邮件配置参数（例如SMPT 主机、用户名、口令）由前面提到的bean 配置机制设置。Email 类提供了该接口的实现。
回页首
Spring 使其保持松散
这些接口就位之后，接下来要考虑的就是如何用松散耦合方式将它们集成在一起。在清单 6 中可以看到信用卡帐户用例的实现。
注意，所有的setter 方法都是由Spring 的配置bean 实现的。所有的依赖关系（也就是三个接口）都可以由Spring 框架用这些bean 注入。createCreditCardAccount() 方法会用服务去执行其余实现。在清单7 中可以看到 Spring 的配置文件。我用箭头突出了这些定义。
回页首
运行应用程序
要运行示例应用程序，首先必须下载Spring 框架及其所有依赖文件。接下来，将框架释放到（比如说）磁盘c:\，这会创建C:\spring-framework-1.2-rc2 （适用于当前发行版本）这样的文件夹。在继续后面的操作之前，还必须下载和释放 Apache Ant。
接下来，将源代码释放到文件夹，例如c:\ 盘，然后创建SpringProject。将Spring 库（即C:\spring-framework-1.2-rc2\dist 下的spring.jar 和C:\spring-framework-1.2-rc2\lib\jakarta-commons 下的commons-logging.jar）复制到SpringProject\lib 文件夹中。完成这些工作之后，就有了必需的构建依赖关系集。
打开命令提示符，将当前目录切换到SpringProject，在命令提示符中输入以下命令：build。
这会构建并运行CreateCreditAccountClient 类，类的运行将创建Customer 类对象并填充它，还会调用 CreateCreditCardAccount 类创建并链接信用卡帐户。CreateCreditAccountClient 还会通过ClassPathXmlApplicationContext 装入Spring 配置文件。装入bean 之
后，就可以通过 getBean() 方法访问它们了，如清单 8 所示。
清单 8. 装入 Spring 配置文件
ClassPathXmlApplicationContext appContext =
new ClassPathXmlApplicationContext(new String[] {
"springexample-creditaccount.xml"
});
CreateCreditCardAccountInterface creditCardAccount =
(CreateCreditCardAccountInterface)
appContext.getBean("createCreditCard");
回页首
结束语
在这篇由三部分组成的Spring 系列的第一篇文章中，我介绍了Spring 框架的基础。我从讨论组成 Spring 分层架构的 7 个模块开始，然后深入介绍了其中两个模块：Spring AOP 和 IOC 容器。
由于学习的最佳方法是实践，所以我用一个工作示例介绍了IOC 模式（像Spring 的IOC 容器实现的那样）如何用松散耦合的方式将分散的系统集成在一起。在这个示例中可以看到，将依赖关系或服务注入工作中的信用卡帐户应用程序，要比从头开始构建它们容易得多。
请继续关注这一系列的下一篇文章，我将在这里学习的知识基础上，介绍Spring AOP 模块如何在企业应用程序中提供持久支持，并让您开始了解 Spring MVC 模块和相关插件。
spring 年编著的《Expert one to one J2EE design and development
Spring Logo 书中，对Java EE正统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-to-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson成为一个改变Java世界的大师级人物。 传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务等。 Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。 编辑本段简介 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ◆目的：解决企业应用开发的复杂性 ◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ◆范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB 多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC 与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
JavaEE JavaEE 是 J2EE的一个新的名称，之所以改名，目的还是让大家清楚J2EE只是Java企业应用。在2004年底中国软件技术大会Ioc微容器（也就是Jdon框架的实现原理）演讲中指出：我们需要一个跨J2SE/WEB/EJB的微容器，保护我们的业务核心组件（中间件），以延续它的生命力，而不是依赖J2SE/J2EE版本。 JavaEE是 J2EE的一个新的名称，之所以改名，目的还是让大家清楚J2EE只是Java企业应用.随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。 在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出：我们需要一个跨J2SE/WEB/EJB的微容器，保护我们的业务核心组件（中间件），以延续它的生命力，而不是依赖J2SE/J2EE版本.此次J2EE改名为Java EE，实际也反映出业界这种共同心声。 JavaEE的核心是EJB3.0, 其提供了更兼便捷的企业级的应用框架。 核心优势编辑 J2EE容易让初学者误解是独立于一套Java的技术方案。 从更深层次来看，Java诞生十年，多年前的业务组件还可以使用，软件应用不再由于语言的更迭革命带来毁灭的打击了。 3功能规定编辑 架构图 让我们看看Java EE 5有哪些新的功能或规定，我们可以从SUN网站下载Java EE 5规范。其架构图如下： JAVA EE 架构图 图中灰色加黑部分是Java EE 5新的功能，我们看到，在WEB层主要加入了JSF 这个新的表现层框架，和我们日常开发关系密切的是，引入了新的Java Persistence标准，这个标准正在由EJB 3.0专家组制定。 值得指出的是，这个Java持久化标准也可以嵌入在WEB层调用，所以，它肯定不会从属于EJB标准，这样，当前所有的Java持久层标准如：
spring相关jar包简介 spring.jar是包含有完整发布的单个jar包，spring.jar中包含除了 spring-mock.jar 里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到 spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。 除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。 (1) spring-core.jar 这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。 (2) spring-beans.jar 这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了。 (3) spring-aop.jar 这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。 (4) spring-context.jar 这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。 (5) spring-dao.jar 这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。 (6) spring-hibernate.jar 这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。 (7) spring-jdbc.jar 这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。 (8) spring-orm.jar 这个jar文件包含Spring对DAO特性集进行了扩展，使其支持iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都要依赖spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar 包。
spring框架 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应
该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB 容器，它们经常是庞大与笨重的，难以使用。 框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。 所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
【黑马程序员】Spring Boot介绍和使用 简介：Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。Spring Boot是一种简化原有Spring应用繁杂配置的微框架。使开发者从繁杂的各种配置文件中解脱出来，通过Spring Boot能够很简单、很快速构建一个优秀的、产品级的Spring基础应用。运行Spring Boot和运行普通的Java 类一样简单，仅仅run一下Spring Boot的入口main()方法即可开启应用；你也可以把Spring Boot应用打成jar，在命令行执行java -jar xxx.jar命令来运行；或者打成war包部署到服务器下运行服务器来开启应用。Spring Boot微框架考虑到了Spring平台和第三方库的情况，所以你需要做的则是最少的操作或配置。 Spring Boot的特点： 1. 创建独立的Spring应用程序 2. 嵌入的Tomcat，无需部署WAR文件 3. 简化Maven配置 4. 自动配置Spring 5. 绝对没有代码生成并且对XML也没有配置要求 Spring boot的使用 1.在ide中打开工程，这里使用的ide是idea，工程的目录结构为： 2、maven配置文件
Struts2和hibernate框架整合实现简单 的注册登陆功能 项目结构： LoginAction.Java package action; import https://www.doczj.com/doc/5c7894397.html,er; import https://www.doczj.com/doc/5c7894397.html,erDAO; import com.opensymphony.xwork2.ActionSupport; public class LoginAction extends ActionSupport { /** * */ private static final long serialVersionUID = 1L; private User user; public User getUser() { return user;} public void setUser(User user) { https://www.doczj.com/doc/5c7894397.html,er = user;} public String execute()throws Exception{ if((user=new UserDAO().LoginCheck(user.getUsername(), user.getPassword(),user.getRole()))==null){
return ERROR; } if(user.getRole()=="1"){ return "admin"; }else{ return SUCCESS;} } } RegistAction.java package action; import https://www.doczj.com/doc/5c7894397.html,er; import https://www.doczj.com/doc/5c7894397.html,erDAO; import com.opensymphony.xwork2.ActionSupport; public class RegistAction extends ActionSupport { /** * */ private static final long serialVersionUID = 1L; private User user=null; private String repassword; public String getRepassword() { return repassword; } public void setRepassword(String repassword) { this.repassword = repassword; } //UserDAO userDao=new UserDAO(); @Override public String execute() throws Exception { User selectUser=new User(); if((selectUser=new UserDAO().selectRegist(user.getUsername()))==null){ User u=new User(); u.setUsername(user.getUsername()); u.setPassword(user.getPassword()); new UserDAO().saveRegist(u); return "success"; }else{ return "error";
一个非常有趣的使用spring框架AOP例子 接触spring有一段时间了，不过都是看的多，写的少，工作忙，公司也不准备用。自己写过一些小东西用到，也只用到了BeanFactory组装对象，JdbcTemplate代替jdbc，事务管理。。。东抓一把，西抓一把，没形成系统。最近也在看spring自带的reference，一时手痒，写了个AOP的创建advice的例子，比之单纯地使用TransationProxyFactoryBean 对AOP的理解又深入了点，打算看看它的源代码，基于CGLIB的实现对类的代理不了解，倒是好奇它如何实现对接口的代理??也就是利用J2SE的动态代理技术。 例子如下：讲述一间书店开始打折促销，规则是每一名顾客只能买一本书，而且已经脱销了。。。。。你可以去掉TestAdvice里的注释看看各种运行结果，具体就不解释咯，在代码注释里。 首先，你必须对增强(advice)有所了解，增强就是在特定连接点执行的动作。advice contains the logic of your aspect。增强，分为4类： 前增强(before)在连接点之前调用 后增强(after)在连接点执行之后调用、 环绕增强(around)完整控制整个方法流程，必须调用MethodInvocation的proceed促使真实操作发生 异常增强针对某个异常抛出时调用 书店，一个buyBook业务： package com.denny_blue.springdemo.aop; public interface BuyBook { public void buyBook(String customer,String book)throws NoThisBookException; } 实现此接口的一个业务对象，如果顾客要买就抛出NoThisBookException异常。 package com.denny_blue.springdemo.aop; public class MyBuyBook implements BuyBook { public void buyBook(String customer,String book)throws NoThisBookException{ if(book.equals("")) throw new NoThisBookException("对不起，没有"+book+"存货了！"); System.out.println(customer+",你好，你已经购买了一本"+book+"!"); } }
Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念。 Rod Johson在2002年编著的《Expert one to one J2EE design and development》一书中，对Java EE正统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-to-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB 的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson 成为一个改变Java世界的大师级人物。 传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务等。 Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而与它们无缝地整合。 Spring简介 Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring 使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ◆目的：解决企业应用开发的复杂性 ◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ◆范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且 Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。 ◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将
框架构件设计 6. 3 框架的基本抗震构造措施抗规 一、延性结构的概念 延性：是指构件和结构屈服后，具有承载能力不降低或基本不降低、且具有足够塑性变形能力的一种性能。一般用延性比表示。 二、延性对结构抗震性能的影响 延性越好，结构的抗震能力也就越好。 在大震下，即使结构构件达到屈服，仍然可以通过屈服截面的塑性变形来消耗地震能，避免发生脆性破坏。在大震后的余震发生时，因为塑性铰的出现，结构的刚度明显变小，周期变长，所受地震力会明显减小，震害减轻。 因此在地震区，结构必须具备一定的延性。并且设防烈度越高、结构高度越大，对延性的要求也越高。 二、延性对结构抗震性能的影响 结构的耗能能力用往复荷载作用下构件或结构的力-变形滞回曲线包含的面积度量。在相同的变形情况下，滞回曲线包含的面积越大，则耗能能力越大，对抗震有利。 梁的耗能能力大于柱的耗能能力，构件弯曲破坏的耗能能力大于剪切破坏的耗能能力。 三、延性框架设计的一般原则 1、强柱弱梁 从抗弯角度来讲，要求柱端截面的屈服弯矩要大于梁端截面的屈服弯矩，使塑性铰尽可能出现在梁的端部，从而形成强柱弱梁。 在梁端出现塑性铰，一方面框架结构不会变成倒塌机制，而且塑性铰的数目多，消耗地震能的能力强；另一方面，受弯构件具有较高的延性，结构的延性有保障。 必须注意以下几点： 1、对工人的管理不亚于对混凝土强度的控制； 2、柱子与楼板体系的混凝土应分别浇灌； 3、混凝土的保护层必须得到保证； 4、钢筋的绑扎务必按照规定办理； 5、混凝土的蜂窝现象不可草率处理。 2、强剪弱弯 要求构件的抗剪能力要比其抗弯承载能力对应的剪力强，从而推迟或避免梁、柱构件过早发生剪切破坏。 构件弯曲破坏的耗能能力大于剪切破坏的耗能能力。 3、强节点（核芯区）、强锚固 节点区域受力复杂，容易发生破坏。节点的可靠与否是关系梁、柱能否可靠工作的前提，必须做到强节点。钢筋锚固的好坏是构件能否发挥承载力的关键。 4、局部加强 提高和加强柱根部（加密箍筋）以及角柱、框支柱等受力不利部位的承载能力和抗震构造措施。
一、基本概念 Spring 的核心是轻量级（Lightweight ）的容器（Container ），它实现了IoC 容器、非侵入性（No intrusive ）的框架，并提供AOP 概念的实现方式，提供对持久层（Persistence ）、事务（Transaction ）的支持，提供MVC Web 框架的实现，并对一些常用的企业服务API （Application Interface ）提供一致的模型封装，是一个全方位的应用程序框架（Application framework ），另外，Spring 也提供了对现有框架（Struts 、JSF 、Hibernate 等）的整合方案。 Spring 旨在分离体系结构的层次，因此每一层都可以修改而不会影响到其它层。每一层都不知道其上层的关注点；就其可能而言，只对所紧挨的下一层有依赖。层与层之间的依赖通常是以接口的形式表现，以确保其耦合尽可能松散。 容器管理事务，容器，贯穿始终：1、对象生命周期的管理。 2、容器本身具备功能，加在自己的类中。需要自己调用则为显示调用。 而尽量用容器隐式调用，Spring 即为隐式 对现有表现层的支持 与ORM 紧密结合，可使用声明式事务管理 AOP 标准接口的实 现（容器管理的声 明式的种种事务） 对JDBC 采用模板回调；声明的JDBC 事务管理. 提供了Bean 工厂 对Bean 工厂的扩 展（比如对事务、国际化的支持） 自己的MVC 实现
调用、声明式编程。 Spring 轻量级容器体现在：只需设置一个Jar 文件到CLASSPATH ，不用去调用它，但又可以拥有其强大的功能。组件的极大程度的复用。 让层与层中耦合度低——Loosely-Coupled 工厂类创建DAO 对象。 声明式编程：在xml 文件中声明。 基于POJO 类，支持事务，事务是根本；而EJB 事务由Container 管理。 Spring 将 View 层与持久层，比如与Hibernate 联系起来。Spring 简化Hibernate 的使用，还可以帮助管理Hibernate 。Spring 本身没有O-R_mapping ，因为有Hibernate ，她已经做得很好了。 Spring 将编译时异常（checked ）转化为运行时异常（runtime ）。比如，JDBC 则为编译时异常，即必须写try…catch ；而Hibernate 程序为运行时异常。 在spring-framework-2.0.5\dist 目录下 有jar 文件、 dtd 文件、 tld 文件。 总之，Spring 是一个轻型容器（light-weight container ），其核心是Bean 工厂（Bean Factory ），用以构造我们所需要的M （Model ）。在此基础之上，Spring 提供了AOP （Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean 工厂的扩展ApplicationContext 更加方便我们实现Java EE 的应用；DAO/ORM 的实现方便我们进行数据库的开发；Web MVC 和Spring Web 提供了Java Web 应用的框架或与其它流行的Web 框架进行集成。 二、IoC （Inversion of Control ） 1、定义：组件．．之间的依赖关系．．．．由容器．．在运行时决定。 例如：B 对象所依赖的A 对象是由 Spring 创建好并且通过Set 方法传递注入过来的。 最基本的优点体现在：若A 为接口，让B 依赖于接口。只看接口不管实现类。 可把工厂类全部替换掉。对象均为容器创建。到时还能把容器的功能融入到其中。 IoC 要求：容器尽量不要侵入到应用程序中去，应用程序本身可以依赖于抽象的接口， 容器根据这些接口所需要的资源注入到应用程序中，也就是说应用程序不会主动向容器 JavaBean 调用/包含 Spring 控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系。
第一章javaEE体系架构 web回顾： web的核心技术就是servlet和JSP，然而组成一个基本的web应用程序还有：客户端浏览器、HTTP协议、javabean、xml、标记库、web服务器和web容器等技术，通过采用JSP+servlet+javaBean技术实现web应用的开发（也就是MVC模式），MVC中的每一个组件，她们都充当着不同的角色servlet就是充当控制器角色负责处理业务和控制业务流程，JSP充当视图角色负责输出响应的结果，javabean充当模型角色，负责具体的业务逻辑和业务数据。 详解：当客户端浏览器向web服务器发出HTTP请求，所请求的消息通过控制器，然后控制器从中获得信息，接着控制器把业务逻辑将信息交给一个适当的模型对象，这个模型对象与数据库进行交互，并且按照请求信息的要求进行处理、应答并收集信息，然后把控制权转交给控制器，控制权得到接过信息后决定采用什么样的视图向客户端浏览器显示响应信息，在这一过程中，控制器并不是直接将信息给某个视图做显示，通常这是一个包括把数据放置在适当的javaweb作用域范围对象的过程，这个作用域对象在控制器和视图之间共享。 Javaweb应用开发的层次： 表示层->业务层->持久层
表示层采用了HTML、jsp、XML等视图技术。 业务层中使用java的组件技术javabean实现业务逻辑，在持久层使用jdbc完成业务数据的持久化，在逻辑分层中采用MVC模式将表示层与业务层进行分离，这样便于修改和加入表示层，把处理过程放置在分离的业务层中也更便于测试。采用DAO模式将业务层与持久层分离，从而使得层与层之间进行数据传输。 Web应用的优缺点： 优点：1.web应用能够在servlet容器中运行，便于管理 负载小、对业务层对象的访问叫简单，可以在不同的Servlet 之间移植。 然而Web应用也存在一定的缺陷： 1.她只针对一个服务器和一个数据库，性能较低，应用有限。 2.无法完成相应的事务处理。 二、JavaEE 1.什么是javaEE企业级应用? JavaEE是一套设计、开发、汇编和部署企业应用程序的规范，目的与核心是提供相应的服务。 JavaEE体系结构的优缺点： 优点：分布式组件、应用程序的可移植性、可靠与稳定性。缺点：较高的资源需求、较高的应用程序服务器费用
柱截面尺寸 柱截面尺寸初选，要同时满足最小截面、侧移限值和轴压比等诸多因素影响。 一般可通过满足轴压比限值惊醒截面估计。 由《建筑抗震规范》（GB50011-2001第637条和表637知，当抗震等级为三级时框架柱的轴压比最大限值［卩N为0.9。 由《混凝土结构设计》教材第281页（4-11和式（4-12估算框架柱的截面尺寸： 式（4-12 N = P FgEn其中 N—地震作用组合下柱的轴向压力设计值； B—考虑地震作用组合后柱的轴向压力增大系数，边柱取1.3,等跨内柱取1.2; F—按简支状态计算的柱的负载面积。 本设计柱网尺寸大部分为7.5m >7.5m,部分8.4m 84m。 gE—折算在单位建筑面积上的重力荷载代表值，可近似取12-15KN/ m2 ;在此取gE =12 KN/ m2。 n—演算截面以上楼层层数。 由式（4-11 N/（fcAc < [ MN]Ac > N/[卩N] X fc 由《抗规》知，框架柱按二级抗震等级设计时，其混凝土强度等级不应低于 C20。在本设计中框架梁和柱的混凝土强度等级均采用 C30。 由《建筑抗震设计》教材第四章第七节知矩形截面框架柱的截面尺寸宜符合以下两点要求:截面的宽度和高度均不宜小于300mm ;
截面长边与短边的边长比不宜大于3。 为此对于首层选用800mm< 800mm部分采用900mm< 900mm。 对于其他层，考虑到施工方便，柱截面不宜变化太多。通过初步估算以及PKPM 验算,最终确定框架的截面尺寸为： 首层-八层:选用800mm<800mm部分采用900mm< 900mm。 梁截面尺寸 框架梁(主梁截面尺寸: 主梁截面高度:h =(1/10~1/12 L =(1/10~1/12 8400=(840~700mm,取h =800mm; 主梁截面宽度:b =(1/2~1/3 h =(1/2~1/3 800=(400~267mm,取 b =400mm。次梁截面 尺寸 (1大部分房间次梁布置形式采用一字形，则次梁的跨度与主梁相同，L =7500mm。同理，取次梁高度h =600mm ;次梁宽度b =300mm。 (2在五层学术报告厅抽柱处采用井字形楼盖，相邻次梁间距为2500mm和2800mm (井字梁间距一般在2米左右。 井字梁截面高度:h =L/16=7500/16=469mm,取h =600mm; 井字梁截面宽度:b =(1/2~1/3 h =(1/2~1/3 600=>(300~200mm,取h =300mm。 4.1.3板厚 板厚根据板的跨度而定，次梁布置方式不同，板的跨度也不同，从而板的厚度也不同。混凝土结构设计规范中规定了确定板厚的方法 简支单向板h/L > 1/35两端连续单向板h/L > 1/40简支双向板h/L > 1/45多跨连续
一.在MyEclipse里先建立一个Web project 的项目，选最新版本的java ee。 二.添加struts2框架支持 1.引入struts2必须得几个jar包，放在WebRoot->WEB-INF->lib 目录下。 2.将WEB应用部署到tomcat服务器上：找到tomacat的安装目录Tomcat6.x\apache-tomcat-6.0.33\conf，打开其中的server.xml文件，在文件末尾上面加入例如
器将部署好的应用纳入到struts2的管辖范围类，具体代码如下
Spring开发教程 Spring教程 (1) Spring框架概述 (2) Spring是什么？ (2) Spring的历史 (3) Spring的使命（Mission Statement） (3) Spring受到的批判 (3) Spring包含的模块 (4) 总结 (5) Spring的IoC容器 (6) 用户注册的例子 (6) 面向接口编程 (7) （用户持久化类）重构第一步——面向接口编程 (8) 重构第二步——工厂（Factory）模式 (9) 重构第三步——工厂（Factory）模式的改进 (9) 重构第四步－IoC容器 (10) 控制反转（IoC）/依赖注入（DI） (10) 什么是控制反转/依赖注入？ (10) 依赖注入的三种实现形式 (11) BeanFactory (13) BeanFactory管理Bean（组件）的生命周期 (14) Bean的定义 (15) Bean的之前初始化 (19) Bean的准备就绪（Ready）状态 (21) Bean的销毁 (21) ApplicationContext (21) Spring的AOP框架 (21) Spring的数据层访问 (21) Spring的声明式事务 (21) Spring对其它企业应用支持 (22)
名词解释 容器： 框架： 框架 容器 组件： 服务： Spring框架概述 主要内容：介绍Spring的历史，Spring的概论和它的体系结构，重点阐述它在J2EE中扮演的角色。 目的：让学员全面的了解Spring框架，知道Spring框架所提供的功能，并能将Spring 框架和其它框架（WebWork/Struts、hibernate）区分开来。 Spring是什么？ Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ?目的：解决企业应用开发的复杂性 ?功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ?范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ■轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ■控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ■面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实
javaEE框架 JAVAEE 的四层模型 JAVAEE使用多层的分布式应用模型，应用逻辑按功能划分为组件，各个应用组件根据他们所在的层分布在不同的机器上。事实上，sun设计JAVAEE的初衷正是为了解决两层模式(client/server)的弊端，在传统模式中，客户端担当了过多的角色而显得臃肿，在这种模式中，第一次部署的时候比较容易，但难于升级或改进，可伸展性也不理想，而且经常基于某种专有的协议――通常是某种数据库协议。它使得重用业务逻辑和界面逻辑非常困难。现在J2EE 的多层企业级应用模型将两层化模型中的不同层面切分成许多层。一个多层化应用能够为不同的每种服务提供一个独立的层，以下是JAVAEE典型的四层结构: 运行在客户端机器上的客户层组件 运行在JAVAEE服务器上的Web层组件 运行在JAVAEE服务器上的业务逻辑层组件 运行在EIS服务器上的企业信息系统(Enterprise information system)层软件 JAVAEE应用程序组件 JAVAEE应用程序是由组件构成的. JAVAEE组件是具有独立功能的软件单元，它们通过相关的J2EE 的四层模
型 JAVAEE使用多层的分布式应用模型，应用逻辑按功能划分为组件，各个应用组件根据他们所在的层分布在不同的机器上。事实上，sun设计J2EE的初衷正是为了解决两层模式(client/server)的弊端，在传统模式中，客户端担当了过多的角色而显得臃肿，在这种模式中，第一次部署的时候比较容易，但难于升级或改进，可伸展性也不理想，而且经常基于某种专有的协议――通常是某种数据库协议。它使得重用业务逻辑和界面逻辑非常困难。现在J2EE 的多层企业级应用模型将两层化模型中的不同层面切分成许多层。一个多层化应用能够为不同的每种服务提供一个独立的层，以下是JAVAEE典型的四层结构: 运行在客户端机器上的客户层组件 运行在JAVAEE服务器上的Web层组件 运行在JAVAEE服务器上的业务逻辑层组件 运行在EIS服务器上的企业信息系统(Enterprise information system)层软件 JAVAEE应用程序组件 JAVAEE应用程序是由组件构成的.JAVAEE组件是具有独立功能的软件单元，它们通过相关的类和文件组装成J2EE应用程序，并与其他组件交互。JAVAEE说明书中定义了以下的JAVAEE组件:
钢筋混凝土框架结构构件截面尺寸选择 1、梁的截面尺寸 (1) 梁的一般要求 在设计钢筋混凝土梁时，首先要确定梁的截面尺寸。其一般步骤是：先由梁的高跨比h/l0确定梁的高度h，再由梁的高宽比h/b确定梁的宽度b（b为矩形截面梁的宽度或T形、I形截面梁的腹板宽度），并将其模数化。对变形和裂缝宽度要求严格的梁，尚应按规定进行扰度验算及裂缝宽度验算。 ①梁的高跨比 下表列出了梁的高跨比下限值，该值可以满足一般正常使用下的变形要求。但对变形要求高的梁，尚应进行扰度验算。 梁的高跨比下限值 构件类型/支承情形简支一端连续两端连续悬臂 1/12 1/3.5 1/15 1/6 独立梁及整体肋形梁的 主梁 整体肋形梁的次梁1/16 1/8.5 1/20 1/8 注：1. 表中数值适用于普通混凝土和fy<=400N/mm2的普通钢筋； 2. 当梁的跨度超过9m时，表中系数宜乘1.2； 3. 对比重γ为15~20kN/m3的轻质混凝土结构，表中系数宜乘以（1.65-0.03γ）且不小于1的系数。 ②梁截面的高宽比 梁截面的高宽比h/b对矩形截面，可选2.0~3.5；对T形截面，可选2.5~4.0。 ③模数要求 当梁高h<=800mm时，h为50mm的倍数；当h>800mm时，h为100mm的倍数。当梁宽b>=200mm时，梁的宽度为50mm的倍数；200mm以下宽度的梁，有b=100mm、150mm、180mm三种。 ④主、次梁的截面尺寸关系 在现浇混凝土结构中，主梁的宽度不应小于200mm，通常为250mm及以上；次梁宽度不应小于150mm。主梁的高度应至少比次梁高50mm或100mm（当主梁下部可能为双排钢筋时）。 (2) 框架梁的截面尺寸 除满足梁的一般要求外，框架梁的截面高度h一般在（1/12~1/8）l0间，截面宽度b可取（1/2~1/4）h；截面宽度b不宜小于200mm；截面高度和截面宽度之比不宜大于4，梁净跨度ln与截面高度之比不宜小于4。 为了确定框架梁的截面尺寸是否选择合适，可在截面尺寸选择后作简单验算：将初步估算的竖向荷载设计值的0.8倍，作用于相应简支梁，进行受弯受剪计算，若其配筋适中，则截面选择合理；配筋过大或过小时，均宜调整截面尺寸。 2、框架柱的截面尺寸 (1) 截面尺寸的一般规定 在抗震设计中，框架柱的截面宽度和高度均不宜小于300mm，圆柱的截面直径不宜小于350mm；柱的截面高度与宽度的比值不宜大于3；柱的剪跨比宜大于2。 柱截面宽度一般不小于框架主梁截面宽度+100mm，通常在（1/15~1/20）H