Spring2.5、Struts2.1、Hibernate3.2、sitemesh、freemarker整合开发常见问题及解决方案

基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发(1)写这个主题的文章在网络上应该暂时没有吧，也看过许多SSH整合开发的书，许多都是旧版本的框架整合，而且大部分都是以XML配置文件的方式，即使谈到Annotation也是针对其中一个框架而言的。

随着开源框架更新版本中不断引进对Annotation的支持，使得我们可以用单方面去管理我们的类与关系，而不用像以往那样，一旦遇到问题，就要不断在Java视图和XML视图中切换。

好，开始吧，既然网络中暂时没有这方面的文章，我就来开创个先例。

自己探索学习一下，也让大家来学习和提出批评和建议。

首选说一下我们的开发准备吧！开发环境：Tom cat 6.0，JDK1.6，MySQL5.0开发工具：Eclipse-jee(Eclipse的官网上下载)所要下载的框架包：struts-2.0.11.2-all.zip，spring-framework-2.5.5-with-dependencies.zip，hibernate-distribution-3.3.1.GA-dist.zip，这三个压缩包在其官方网站都可以下载。

当然，这个小项目所要用到不止这些，我们用到的时候再去下载。

好，我们来开始第一阶段的探索——Hibernate3.3的Annotation的实现。

新建我们的Dynamic Web Project，取名为"ssh_annotation”，配置Tom cat6.0的支持，打开MySQL，建立一个空数据库，取名为"ssh_annotation"。

记得，要引进MySQL 的JDBC驱动包mysql-connector-java-5.0.8-bin.jar。

在解压缩的hibernate-distribution-3.3.1.GA目录中，把hibernate.jar，和\lib\required\下的所用jar包引进到我们项目的lib目录下。

Java的struts、spring、hibernate精通SSH三大框架的底层机制及原理1. 什么是SSH框架SSH是由Struts、Spring、Hibernate三个框架整合而成的，它是一种企业级、全栈式框架，非常适合开发大型Web应用程序。

Struts是MVC架构模式中的控制器层，负责接收请求并转化成对应的业务逻辑进行处理，同时也控制着视图层进行渲染。

Spring是一个轻量级的开源框架，它可以被用来构建Java企业级应用，能够提供全周期的、全栈式的框架服务。

Hibernate是一个ORM（对象关系映射）框架，之前在持久化层需要进行数据库的操作，但是Hibernate可以让开发者不用直接操作数据库，而是通过Java对象与数据库进行交互。

2. SSH框架的优势SSH框架的三个组件各自拥有一系列的优势。

Struts提供了用于Web开发的MVC架构，使得应用程序的开发和维护更加清晰、明了。

Spring专注于解决企业开发中的复杂问题，比如事务管理、安全管理、远程调用、Web框架等。

Hibernate则是优秀的ORM框架，可以将Java对象与关系型数据库进行映射，让开发者不用关心具体的SQL语句。

3. SSH框架的实现机制SSH框架的三个组件相互整合，形成了一个高效、稳定、易于使用的开发框架。

在SSH框架中，Web请求首先被Struts2框架接收，Struts2框架通过ActionContext来向Action中注入Spring容器管理的Bean完成业务逻辑处理，而Bean之间的关系都是由Spring的IOC容器维护的。

声明式事务管理交给Spring框架完成，Hibernate框架在ORM层将Java对象映射到数据库记录。

下面分别来详细介绍一下SSH框架各自的底层机制及原理。

3.1 Struts2框架Struts2框架是一个基于MVC模式的Web应用程序框架。

在Struts2中，负责接收请求转发的控制器为Action。

Struts的原理和优点.Struts工作原理MVC即Model—View—Controller的缩写，是一种常用的设计模式。

MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

MVC的工作原理，如下图1所示：Struts 是MVC的一种实现，它将Servlet和JSP 标记(属于J2EE 规范）用作实现的一部分。

Struts继承了MVC的各项特性,并根据J2EE的特点，做了相应的变化与扩展.Struts的工作原理，视图:主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库: Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。

控制：在Struts中,承担MVC中Controller角色的是一个Servlet，叫ActionServlet。

ActionServlet是一个通用的控制组件。

这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。

它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类）。

另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean），并传给动作类（通常称之为ActionBean）。

动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。

最后动作类把控制权传给后续的JSP 文件，后者生成视图。

所有这些控制逻辑利用Struts-config.xml文件来配置。

模型：模型以一个或多个java bean的形式存在。

这些bean分为三类：Action Form、Action、JavaBean or EJB.Action Form通常称之为FormBean，封装了来自于Client的用户请求信息,如表单信息。

Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。

Spring框架从创建伊始就致力于为复杂问题提供强大的、非侵入性的解决方案。

Spring 2.0当中为缩减XML配置文件数量引入定制命名空间功能，从此它便深深植根于核心Spring框架（aop、context、jee、jms、 lang、tx和util命名空间）、Spring Portfolio项目（例如Spring Security）和非Spring项目中（例如CXF）。

Spring 2.5推出了一整套注解，作为基于XML的配置的替换方案。

注解可用于Spring管理对象的自动发现、依赖注入、生命周期方法、Web层配置和单元/集成测试。

探索Spring 2.5中引入的注解技术系列文章由三部分组成，本文是其中的第二篇，它主要讲述了Web层中的注解支持。

最后一篇文章将着重介绍可用于集成和测试的其它特性。

这个系列文章的第一部分论述了Java注解（annotation）是如何代替XML来配置Spring管理对象和依赖注入的。

我们再用一个例子回顾一下：@Controllerpublic class ClinicController {private final Clinic clinic;@Autowiredpublic ClinicController(Clinic clinic) {this.clinic = clinic;}...@Controller表明ClinicController是Web层组件，@Autowired请求一个被依赖注入的Clinic实例。

这个例子只需要少量的XML语句就能使容器识别两个注解，并限定组件的扫描范围：<context:component-scanbase-package="org.springframework.samples.petclinic"/>这对Web层可谓是个福音，因为在这层Spring的XML配置文件已日益臃肿，甚至可能还不如层下的配置来得有用。

我自学Struts2+ Spring2.5+Hibernate框架，用了一天的时间，才将Struts2 + Spring2.5+Hibernate3.1的框架搭建好。

由此想到各位新手应该和我一样啊，我将我的经验分享给大家。

但首先声明，本文档只限于有对j2ee有相关了解的人看，如果您对j2ee开发不了解，可能没有什么作用。

创建一个web工程：
填写工程名称，选择版本：
点击“finish”完成，这样一个web项目就常见好了。

首先我们在src 下创建一个struts.xml文件
填写文件名：
建struts.xml 后，从下载的struts2-2.x.x-all.zip 的拿到struts.xml的头文件
我们找到struts-core.2.x.x.jar 包，将其解压，从中找到到struts-2.1.dtd 文件，复制scr 目录下，并修改头文件，如下图：（这样没网的时候也会有提示）
Struts 的环境已经好了，下面我们添加Spring 支持
Spring 环境添加完成，最后添加Hibernate环境；首先我们要创建一个连接：
连接创建好了，现在添加hiberate 环境
选择刚刚创建的链接
添加s-s-h环境结束（如下图），报错，是正常的，因为我们还没有添加jar包。

添加3大框架的jar包，挑出以下jar ,添加到WEB-INF /lib 目录下
环境基本配置完成，现在要做的是修改spring配置文件，和web.xml文件
Spring （2.5）头文件
数据源的配置
Web.xml 的配置
OK,部署运行吧；
文子。

搭建SSH框架：Struts1.* + Spring2.5 + Hibernate3.0 一，项目结构：图(1)Jsp页面省略，主要是一些添删改查的页面；二，开始搭建项目环境，步骤如下：使用平台：MyEclipse6.0/6.5框架版本：Struts1.* + Spring2.5 + Hibernate3.0；1，添加过程：1>，新建项目: 打开MyEclipse,在Package Explorer视图下，右键单击New-> Web Project；注意：在新建项目时，JDK的版本最好要选择Java EE 5.0;因为版本过低，可能有些JSP方面的功能不支持；新建玩项目之后，把该导的包导入到下面,下图为SS H 框架所需要的Jar包，注意，该项目用的是ORACLE数据库；其中，activation与mail这两个包为Java发邮件的包;classes12为Oracle数据库的驱动包，如果不是Oracle数据库,可更换该Jar包;dwe为Ajax dwr 框架中的包;2>,接着就开始用MyEclipse辅助开发Struts,Spring,Hibernate了;3>,首先MyEclipse辅助开发Struts,方法:右键单击你所建的项目，出现一级菜单,选择Myeclipse,选择Myeclipse之后会出现二级菜单,接着选择Add Struts Capabilities;;接着具体操作如下面图示：点击Finish按钮完成;完成之后，可将包删除；在上图中，如果那个勾没有去掉的话，就会自动生产如下标签：当然，如果你觉得标签对你没什么用的话，可以删除；如果该勾去掉的话，就只生成标签，这是Struts的核心标签;4>,MyEclipse辅助开发Spring,方法跟上面的一样，选择Add Spring apabilities;;接着具体操作如下面图示：然后点击Next，具体操作如下图：接着点击 Finish按钮，完成此项操作；5>,,最后MyEclipse辅助开发Hibernate,在执行和上面类似方法之前,Hibernate 需要先做另外一件事情，那就是和数据建立连接，具体操作如下图：点击上图位置的或者右边的>> ，然后再选择MyEclipse Database Explorer切换到如下图页面:，然后右键单击，新建一个Database Driver;如下图：下面这个截图是该项目的数据库链接图：如图所示，测试数据库链接成功；然后可直接点击Finish完成；接着切换到窗口，按照上面第三小步的方法，选择Add Hibernate apabilities;;接着具体操作如下面图示：点击下一步：点击下一步：点击下一步：点击下一步：点击 Finish 完成；6>,最后一步，就是运用Hibernate的映射机制，把数据库的表与JAVA的对形成一个关系映射；在此之前，首先应该在项目SRC的目录下面新建一个包，如该项目所示，用来存放映射生成的POJO对象以及映射文件；如下图：有一点说一下，你生成的*.hbm.xml文件可能不止一个，对，你可以把它们整合到一个文件中；然后新建按第五小步的方法，把窗口切换到MyEclipse Database Explorer界面，然后打开右键刚才所建立的链接，选择属于你自己的用户；然后选择Tble;右键选择如上图的属性：接下来的操作如下图：点击 Next,进入下一步：点击 Next,进入下一步：至此，项目环境己经搭建完成；三，项目搭建完成，SSH各个部分配置文件的说明，以及它们之间存在的关系：1，首先是Struts的核心配置文件，即struts-config.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN""/dtds/struts-config_1_2.dtd"><struts-config><data-sources /><form-beans><!—建立Form表单，在此处进行登记 -→<form-bean name="userForm"type="erForm" /> </form-beans><global-exceptions /><global-forwards /><!—各个Action对应与之相对应的表单 -→<action-mappings><!-- 用户管理 --><action parameter="opers" attribute="userForm" name="userForm"path="/doUser" scope="request"><forward name="login_ok" path="/welcome.jsp"></forward><forward name="login_no" path="/index.jsp"></forward> </action></action-mappings><controllerprocessorClass="org.springframework.web.struts.DelegatingRequestProc essor"></controller><message-resourcesparameter="ermanagerview.struts.ApplicationResources"> </message-resources><!—Spring辅助Struts管理Struts-→<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/action-servlet.xml" /></plug-in></struts-config>2,其次就是Springd的applicationContext.xml文件和action-servlet.xml文件：applicationContext.xml文件：<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd"><!-- Session 工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate.cfg.xml"><!-- 可以不要配置文件（hibernate.cfg.xml），直接写在这个Spring的配置文件中 --></property></bean><!-- 模板 --><bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 事务器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManage r"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 对外代理 --><!-- 1,用户管理 --><bean id="userDaoImp"class="erDaoImp"><property name="hibernateTemplate" ref="hibernateTemplate" /> </bean><bean id="userServiceTarget"class="erServiceImp"> <property name="userdao"><ref local="userDaoImp" /></property></bean><bean id="userService"class="org.springframework.transaction.interceptor.TransactionProxyF actoryBean"><property name="transactionManager"><ref local="transactionManager" /></property><property name="target"><ref local="userServiceTarget" /></property><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>action-servlet.xml文件：<!—Spring辅助Struts管理Struts-<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd"> <bean name="/doUser"class="erAction"scope="prototype"></bean></beans>3,最后就是Hibernate的hibernate.cfg..xml文件:<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="ername">wangxiaodong</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.2:1521:ALIZEEDB</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><propertyname="myeclipse.connection.profile">Test</property><property name="connection.password">donny</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><mappingresource="com/ygkq/usermanager/model/entity/User.hbm.xml" /></session-factory></hibernate-configuration>该文件基本上不用动，都是自动生成的代码；当然，你也可以根据自己的需要添加代码，例如，你想在执行HQL语句的时候让它显示SQL语句，可将<property name="hibernate.show_sql">true</property>插入代码中；另外在图(1)中还有两个配置文件没有提到，那就是log4j.properties 与mytag.tld；其中log4j.properties是配置日志信息的；而mytag.tld主一个自定义标签；四，SSH框架搭建完成：SSH框架基本搭建完成，如果有不对或者不妥之处，请随时指教！~E-mail:jerry8059@。

用spring、Hibernate、Struts组建轻量级架构发布时间：2006.03.09 00:13 来源：CSDN 作者：轻量级J2EE架构版本0.1版权© 2005 成湘均文中肯定有错误和理解不正确的地方，欢迎给我指正。

我的邮箱：chengxiangjun@ -------------------------------------------------------------------------------- 目录前言1. 整体框架1.1. UI层1.2. 业务层1.3. 数据持久层1.4. 域对象层2. Struts2.1. 概述2.2. 快速入门2.3. ActionForm2.4. Action2.5. 客户端验证3. springFramework3.1. 概述3.2. 为什么使用Spring3.3. 快速入门3.4. 搭建Web应用环境3.5. Spring IOC3.6. Spring AOP4. hibernate4.1. 概述4.2. 为什么使用Hibernate4.3. 快速入门4.4. 工具的配合使用4.4.1. 生成影射文件4.4.2. 生成映射对象4.4.3. 根据映射对象生成映射文件4.5. 专用词4.5.1. cascade(级联)4.5.2. inverse(反转)4.5.3. Lazy Loading(延时装载)4.6. 一对一表关联操作4.7. 多对一表关联操作4.8. 一对多表关联操作4.9. 多对多表关联操作4.10. 与spring的结合使用4.11. Hibernate DAO5. log4j5.1. 概述5.2. 快速入门前言在java的应用领域，有许多成熟的开源软件,利用它们一样可以打造优越、灵巧的应用框架，本文首先将先介绍所要构建的系统结构和借助的开源产品。

然后逐一讲解各开源软件的具体运用。

希望本文能给那些正在学习这些开源软件的同行提供参考。

Struts2+Hibernate3.2+Sprint2.5整合Hibernate使用数据库连接池、MyEclipse6.5Tomcat6.0创建项目，整合Hibernate右键项目，MyEclipse—>Add Hibernate Capabilities使用Spring管理，把勾去掉整合Spring2.5右键项目，MyEclipse—>AddSpring Capabilities配置Hibernate的数据源Hibernate自带的连接池算法相当不成熟。

它只是为了让你快些上手，并不适合用于产品系统或性能测试中。

出于最佳性能和稳定性考虑你应该使用第三方的连接池。

只需要用特定连接池的设置替换hibernate.connection.pool_size 即可。

这将关闭Hibernate自带的连接池。

例如，你可能会想用C3P0.C3P0是一个随Hibernate一同分发的开源的JDBC连接池，它位于lib目录下。

如果你设置了hibernate.c3p0.*相关的属性，Hibernate将使用C3P0ConnectionProvider来缓存JDBC连接。

如果你更原意使用Proxool，请参考发行包中的hibernate.properties并到Hibernate网站获取更多的信息。

<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xsi:schemaLocation="/schema/beans[url]/schema/beans/spring-beans-2.0.xsd[/url] [url]/schema/jee[/url][url]/schema/jee/spring-jee-2.0.xsd[/url]"><!--********************配置数据源，采用C3P0********************--> <bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"><value>com.microsoft.sqlserver.jdbc.SQLServerDriver</value> </property><property name="jdbcUrl"><value>jdbc:sqlserver://localhost:1433;DatabaseName=shopping</value> </property><property name="user"><value>sa</value></property><property name="password"><value>sa</value></property><!--连接池中保留的最小连接数。

Struts2+spring2+hibernate3整合方案最近闲来无事可做，于是开始学习struts2。

Struts2和struts1、webwork2有什么区别我也不说了，网上有很多这方面的资料。

以前在项目中从未使用过struts，一直使用spring+hibernate，现在既然学习了Struts，也不能浪费，于是乎开始琢磨着怎么整合这3个框架。

整合原理以spring为容器，管理hibernate的DAO和Struts2的Action。

一、准备工作Struts2.06+spring2.5+hibernate3.2+jdk6.0+myeclipse6.0+tomcat5.5+mysql 5.0以上是整合的原料。

下面以一个注册登陆的例子来开始我们的整合过程。

这个例子很简单，下面是它的sql脚本内容:CREATE TABLE `user` (`userid` int(11) NOT NULL AUTO_INCREMENT,`username` varchar(20) NOT NULL,`password` varchar(16) NOT NULL,`email` varchar(30) NOT NULL,PRIMARY KEY (`userid`)) ENGINE=InnoDB DEFAULT CHARSET=utf-8;二、开始行动包结构可以参考下图1) Struts部分:建立struts.xml和struts.propertiesStruts.xml内容如下：<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configur ation 2.0//EN" "/dtds/struts-2.0.dtd" ><struts><package name="user_curd" extends="struts-default"><global-results><!-- 下面定义的结果对所有的Action都有效 --><result name="exception">/error.jsp</result></global-results><global-exception-mappings><!-- 指Action抛出Exception异常时，转入名为exception的结果。

Struts2.1+Spring3.0+JPA1.0(Hibernate3.3实现)例子文章分类:Java编程本文代码是传智播客黎活明老师所讲的《Spring2.5视频教程》各种示例的综合，在此把所有框架升级到最新版本整合一下。

/blog/582117所用jar包：Struts：struts-2.1.8.1\lib下除了各种plugin(保留struts2-spring-plugin-2.1.8.1.jar)的所有文件Spring：spring-framework-3.0.0.RELEASE\dist下的所有文件Hibernate：hibernate-distribution-3.3.2.GA下的hibernate3.jar\lib\bytecode\cglib下的cglib-2.2.jar\lib\optional\ehcache下的ehcache-1.2.3.jar\lib\required下的所有文件hibernate-annotations-3.4.0.GA下的hibernate-annotations.jar\lib下的ejb3-persistence.jar，hibernate-commons-annotations.jar hibernate-entitymanager-3.4.0.GA下的hibernate-entitymanager.jar \lib\test下的log4j.jar，slf4j-log4j12.jarMySQL：mysql-connector-java-5.1.10-bin.jarJUnit：4JDK：jdk-6u14-windows-i586.exeTomcat：apache-tomcat-6.0.18.zip项目名：testPerson.javaJava代码package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;@Entitypublic class Person implements Serializable {private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}}package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.Id;@Entitypublic class Person implements Serializable { private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}} PersonService.javaJava代码package com.test.service;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();}package com.test.service;import java.util.List;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();} PersonServiceBean.javaJava代码package com.test.service.impl;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Person o").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}}package com.test.service.impl;import java.util.List;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Persono").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}} PersonAction.javaJava代码package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) { this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) { this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) {this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) {this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}PersonServiceTest.javaJava代码package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);}@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}}package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}} META-INF\persistence.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><!-- 数据库方言--><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><!-- 数据库驱动--><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><!-- 数据库用户名--><property name="ername" value="root"/><!-- 数据库密码--><property name="hibernate.connection.password" value="1234"/><!-- 数据库连接URL --><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;char acterEncoding=UTF-8"/><!-- 最大抓取深度--><property name="hibernate.max_fetch_depth" value="3"/><!-- 更新方式创建库表--><property name="hibernate.hbm2ddl.auto" value="update"/><!-- 显示SQL --><property name="hibernate.show_sql" value="true"/><!-- 格式SQL --><property name="hibernate.format_sql" value="true"/><!-- 使用二级缓存--><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence><?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><!-- 数据库方言--><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><!-- 数据库驱动--><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><!-- 数据库用户名--><property name="ername" value="root"/><!-- 数据库密码--><property name="hibernate.connection.password" value="1234"/><!-- 数据库连接URL --><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;char acterEncoding=UTF-8"/><!-- 最大抓取深度--><property name="hibernate.max_fetch_depth" value="3"/><!-- 更新方式创建库表--><property name="hibernate.hbm2ddl.auto" value="update"/><!-- 显示SQL --><property name="hibernate.show_sql" value="true"/><!-- 格式SQL --><property name="hibernate.format_sql" value="true"/><!-- 使用二级缓存--><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence> src\beans.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans><?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans> src\ehcache.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><!--defaultCache节点为缺省的缓存策略maxElementsInMemory 内存中最大允许存在的对象数量eternal 设置缓存中的对象是否永远不过期overflowToDisk 把溢出的对象存放到硬盘上timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉timeToLiveSeconds 指定缓存对象总的存活时间diskPersistent 当jvm结束是是否持久化对象diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间--><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache><?xml version="1.0" encoding="UTF-8"?><!--defaultCache节点为缺省的缓存策略maxElementsInMemory 内存中最大允许存在的对象数量eternal 设置缓存中的对象是否永远不过期overflowToDisk 把溢出的对象存放到硬盘上timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉timeToLiveSeconds 指定缓存对象总的存活时间diskPersistent 当jvm结束是是否持久化对象diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间--><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache>src\struts.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN""/dtds/struts-2.1.dtd"><struts><!-- 指定Web应用的默认编码集,相当于调用HttpServletRequest的setCharacterEncoding方法--><constant name="struts.i18n.encoding" value="UTF-8"/><!-- 该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。

SSH_三大框架介绍SSH是指Struts、Spring和Hibernate三个开源框架的整合，其中每个框架都有自己的设计思想和特点，通过整合，可以充分发挥它们的优势，提高开发效率和系统性能。

下面将分别介绍这三个框架。

1. Struts：Struts是一个基于MVC设计模式的Web应用程序框架，它将应用程序分为三个层：模型（Model）、视图（View）和控制器（Controller）。

模型负责处理业务逻辑，视图负责展示数据，控制器负责接收用户输入和导航请求。

Struts通过配置文件定义请求的映射和处理逻辑，通过统一的控制器Servlet接收请求，根据配置文件将请求转发给相应的Action。

在Action中进行请求处理和业务逻辑的实现。

2. Spring：Spring是一个轻量级的IoC（Inverse of Control）容器和应用程序框架，它主要解决企业应用中的复杂性问题。

Spring的核心思想是面向接口编程和依赖注入。

通过Spring的IoC容器管理对象的生命周期和依赖关系，将对象的创建和销毁过程交给容器处理。

通过依赖注入，可以将对象之间的依赖关系解耦，提高代码的可维护性和可测试性。

Spring还提供了丰富的功能模块，如AOP（Aspect-Oriented Programming）框架、事务管理、远程调用等，可以在应用程序中灵活地配置和使用。

Spring的优点是具有良好的灵活性和扩展性，可以与其他框架进行无缝集成，支持多种数据库和应用服务器。

同时，Spring还提供了很强的层次化管理和面向切面编程的能力，使得开发人员可以更加精细地控制应用程序的流程和行为。

3. Hibernate：Hibernate是一个开源的对象关系映射框架，用于将Java对象映射到关系数据库中的表结构上。

Hibernate通过配置文件和注解，提供了一种方便的方式来实现数据的持久化和检索。

Hibernate根据对象的映射关系，自动生成相应的SQL语句，实现了对象与数据库之间的映射和转换。

Spring部分学习笔记讲师:梁建全liangjq@目录Spring部分学习笔记 (1)DAY01 (5)一、Spring框架的作用和好处 (5)二、Spring框架对Bean组件的管理 (5)1、使用方法： (5)2、Spring容器对Bean组件的管理 (5)3、Spring框架的IoC机制 (6)A.DI (依赖注入) (6)B.各种类型数据的注入 (7)C.IoC(Inverse of Controller,控制反转) (9)三、AOP概念 (9)1、什么是AOP? (9)2、AOP基本应用 (9)A.引入AOP开发包 (9)B.定义一个Bean组件(方面组件)，封装共通处理 (9)C.在applicationContext.xml中定义AOP配置 (9)3、AOP相关概念 (10)4、通知类型 (10)5、切入点表达式 (11)6、AOP练习完成记录用户操作日志示例。

(11)7、编写一个AOP示例，异常处理方面 (13)DAY02 (14)一、Log4j工具介绍 (14)1、体系结构 (14)2、消息级别 (14)二、Spring注解配置 (15)1、组件的自动扫描 (15)2、AOP注解标记 (15)3、(异常处理)案例重构 (15)4、XML和注解两种配置形式 (16)DAY03 (17)一、Spring对数据访问层的支持 (17)1、提供了事务管理 (17)2、提供了DAO实现支持 (17)3、如何整合JDBC技术 (17)4、如何整合Hibernate技术 (19)5、Spring整合Hibernate后，如何使用Hibernate中的Session对象 (21)二、Spring如何与Struts2框架整合 (22)1、添加Struts2框架 (22)2、编写Action，需要使用DAO组件采用DI方式注入 (22)3、Spring容器中定义Action组件，注入DAO (22)4、在struts.xml中定义Action组件和请求配置 (22)5、在web.xml中添加配置，在启动tomcat时，实例化Spring容器 (23)DAY04 (24)一、Spring与Struts2、Hibernate 整合 (24)1、SSH工作流程 (24)二、ssh开发步骤 (25)1、引入开发包 (25)2、编写实体类和映射文件hbm.xml(可以利用MyEclipse工具) (25)3、编写DAO组件 (26)4、在Spring配置文件中定义DAO,SessionFactory,DataSource按以下关系注入 (26)5、添加Struts2配置文件及控制器配置 (27)6、编写Action组件,需要使用Service或DAO时，采用名称匹配规则注入 (27)7、在struts.xml中添加Action组件配置（代码在5、中） (27)8、修改jsp，利用struts2标签完成显示 (27)9、修改web.xml，添加Listener配置，实例化Spring容器 (27)10、按ssh-2图示检查一下流程。

Struts2.5+Hibernate3.1+Spring应用开发实例.（Hibernate和Spring是新的知识点，先单独强化，然后再整合训练）任务一：Hibernate（10课时）该任务包括两个部分内容一是Hibernate的基础知识，二是实际完成一个Hibernate应用。

要求：掌握Hibernate的基础知识，掌握开发Hibernate应用的方法。

任务二：Sping（10课时）该任务包括两个部分内容一是介绍Spring的基础知识，二是完成一个Spirng 应用。

要求：掌握Spring的基础知识，掌握开发Spirng应用的方法。

任务三：Hibernate和Spring的联合开发（8课时）使用Hibernate和Spring框架完成Java应用开发要求：掌握使用Hibernate和Spring框架开发Java应用程序的过程。

任务四：基于Struts+Hibernate+Spring的网上购物系统开发（28课时）结合Hibernate和Spring改写《Java Web 应用开发项目教程》的前台要求：掌握使用Struts+Hibernate+Spring框架开发网上购物系统的方法实训要求：1.每位同学独立完成2.每部分内容按时提交代码和学习报告（总成绩由每次的节点成绩统计获得）软件环境需求：1.操作系统：WindowsXP2.数据库及驱动程序：Microsoft SQLServer 2005 JDBC3.JDK: JDK64.IDE：MyEclipse7.05.服务器：Tomcat6.0任务一Hibernate1.1Hibernate基础知识1.Hibernate简介Hibernate是一种Java语言下的对象-关系映射解决方案，它是一种自由、开源的轻量级框架，用于将面向对象的对象模型映射到传统的关系数据库中。

Hibernate对JDBC进行了轻量级的对象封装，不仅提供从Java数据类型到SQL数据类型的ORM映射，还提供数据查询和数据缓存功能，大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间，使得Java程序员可以完全使用面向对象的编程思维通过Hibernata API操作关系数据库。

人事面试问题1人事面试问题汇总11、介绍一下你自己2、在五年的时间内，你的职业规划？3、说一个你曾经提过的建议4、你对同事哪些行为无法容忍5、如果现在有足够的钱，你会退休吗1、你觉得你个性上最大的优点是什么？2、什么能激发你在工作中的最佳发挥？3、谈谈你如何帮助他人解决争端4、你的工作哲学是什么5、你希望薪水多少1、你的同学如何评价你？2、如果通过这次面试我们单位录用了你，但工作一段时间却发现你根本不适合这个职位，你怎么办？3、谈谈你与领导之间存在的问题4、金钱和工作，哪个对你更重要5、你希望老板具有什么样的特质1、最近一年，你做了哪些事情来提高自己2、你希望自己在团队中处于什么位置3、你是否有这个行业的工作经验4、你是否愿意把公司利益放在个人利益之上5、作为被面试者给我打一下分？1、谈谈你的理想职业？2、你认为自己成功吗3、你有团队合作精神吗4、你会怎样弥补你的经验不足5、你在工作中最失望是什么1、描述你的工作原则2、描述你工作中最大的快乐3、你怎么知道自己在事业上是成功的4、你会拒绝什么样的人一起工作5、如果被录用，你希望工作多久1、你想在这份工作中追求什么2、在完成某项工作时，你认为领导要求的方式不是最好的，而另一位非主管领导对你提出工作意见更为合适，你应该怎么做？3、谈谈你在压力下工作的能力4、你是否愿意加班5、你是否认为你的能力超过了职位要求1、你最大的优点是什么2、形容一下你的管理方式3、为什么你认为自己能胜任这个工作4、你对公司的价值5、工作中什么事会让你失望1、怎样看待学历和能力？2、你从工作错误中学到什么3、老师怎样评价你的优点4、你认为你在学校属于好学生吗？5、你有什么问题要提问人事面试问题汇总12016-04-19 12:40 | #2楼1. 自我介绍 ----我叫罗丹，25岁,首先非常感谢贵公司给我这次面试的机会.我毕业于湖南理工学院计算机系我之前在岳阳XX公司中工作2年,在这期间，我熟悉了项目开发流程,加深了对面向对象设计思想,熟练的将工作中遇到的新的框架或技术,如struts2.1,hibernate3.2,spring2.5,dwr,jQuery等运用到各种项目当中。

SSH三大框架（StrutsSpringHibernate）struts0、Struts1工作流程：（1）检索和用户请求匹配的ActionMapping实例。

如果不存在此示例，就返回用户请求路径无效。

（2）如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。

（3）根据配置信息决定是否需要表单验证，如果需要验证，就调用ActionForm的validate()方法。

（4）如果ActionForm的validate()方法返回null或返回的ActionErrors对象里不包含ActionMessage对象，就表示表单验证成功。

（5）ActionServlet根据ActionMapping实例包含的映射信息决定将请求转发给哪个Action。

如果相应的Action实例不存在，就先创建这个实例，然后调用Action的execute()方法。

（6）Action的execute()方法返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象所指向的JSP 组件。

（7）通过ActionForward对象指向的JSP组件生成动态网页，返回给客户端。

1、Struts2工作流程：(包含拦截器处理部分，详细描述)1、客户端向Servlet容器（如Tomcat）提交一个请求2、请求经过一系列过滤器（如ActionContextCleanUp (已被JVM和WEB容器废弃的空对象) 过滤器等）3、核心控制器被调用，询问ActionMapper来决定请求是否需要调用某个Action ?4、如果ActionMapper决定需要调用某个Action，核心控制器把控制权委派给ActionProxy （备注：JSP请求无需调用Action）5、ActionProxy通过Configuration Manager询问框架的配置文件（struts.xml），找到需调用的Action类6、ActionProxy创建一个ActionInvocation的实例，(ActionInvocation的作用是如何执行Action，拦截器的功能就是在ActionInvocation中实现的)7、ActionInvocation负责调用Action，在此之前会依次调用所有配置的拦截器8、Action执行完毕，ActionInvocation负责根据结果码字符串在struts.xml的配置中找到对应的返回结果9、拦截器被再次执行10、过滤器被再次执行2、Struts1和Struts2区别：1、Action的实现方面：Struts1要求必须统一扩展自Action类，而Struts2中可以是一个普通的POJO2、线程模型方面：Struts1的Action工作在单例模式，一个Action的实例处理所有的请求。

Spring、SpringMVC、Struts2之间的区别⼀、Spring与SpringMVC的区别：spring是⼀个开源框架，是为了解决企业应⽤程序开发，功能如下：功能：使⽤基本的JavaBean代替EJB，并提供了更多的企业应⽤功能范围：任何Java应⽤ Spring是⼀个轻量级的控制反转（IoC）和⾯向切⾯（AOP）的容器框架。

1、轻量——从⼤⼩与开销两⽅⾯⽽⾔Spring都是轻量的。

完整的Spring框架可以在⼀个⼤⼩只有1MB多的JAR⽂件⾥发布。

并且Spring所需的处理开销也是微不⾜道的。

此外， Spring是⾮侵⼊式的：典型地，Spring应⽤中的对象不依赖于Spring的特定类。

2、控制反转——Spring通过⼀种称作控制反转（IoC）的技术促进了松耦合。

当应⽤了IoC，⼀个对象依赖的其它对象会通过被动的⽅式传递进来，⽽不是这个对象⾃⼰创建或者查找依赖对象。

你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，⽽是容器在对象初始化时不等对象请求就主动将依赖传递给它。

3、⾯向切⾯——Spring提供了⾯向切⾯编程的丰富⽀持，允许通过分离应⽤的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进⾏内聚性的开发。

应⽤对象只实现它们应该做的——完成业务逻辑—— 仅此⽽已。

它们并不负责（甚⾄是意识）其它的系统级关注点，例如⽇志或事务⽀持。

4、容器——Spring包含并管理应⽤对象的配置和⽣命周期，在这个意义上它是⼀种容器，你可以配置你的每个bean如何被创建——基于⼀个可配置原型（prototype），你的bean可以创建⼀个单独的实例或者每次需要时都⽣成⼀个新的实例——以及它们是如何相互关联的。

然⽽，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞⼤与笨重的，难以使⽤。

5、框架——Spring可以将简单的组件配置、组合成为复杂的应⽤。

Struts1、Struts2、Hibernate、Spring框架工作原理介绍Struts1工作原理Struts1工作原理图1、初始化：struts框架的总控制器ActionServlet是一个Servlet，它在web.xml中配置成自动启动的Servlet，在启动时总控制器会读取配置文件(struts-config.xml)的配置信息，为struts中不同的模块初始化相应的对象。

(面向对象思想)2、发送请求：用户提交表单或通过URL向WEB服务器提交请求，请求的数据用HTTP协议传给web服务器。

3、form填充：struts的总控制器ActionServlet在用户提交请求时将数据放到对应的form对象中的成员变量中。

4、派发请求：控制器根据配置信息对象ActionConfig将请求派发到具体的Action，对应的formBean一并传给这个Action中的excute()方法。

5、处理业务：Action一般只包含一个excute()方法，它负责执行相应的业务逻辑(调用其它的业务模块)完毕后返回一个ActionForward对象。

服务器通过ActionForward对象进行转发工作。

6、返回响应：Action将业务处理的不同结果返回一个目标响应对象给总控制器。

7、查找响应：总控制器根据Action处理业务返回的目标响应对象，找到对应的资源对象，一般情况下为jsp页面。

8、响应用户：目标响应对象将结果传递给资源对象，将结果展现给用户。

Struts1优缺点（为什么要用strust1）1.优点：①开源的框架，结构清晰②是MVC的经典实现（MVC是一种思想，而不是一种技术）③处理异常机制，实现国际化④具有强大的标签库⑤解决了JSP页面存在大量的JAVA代码，维护起来方便⑥在formBean中会自动提交，不会去使用传统的get、set方法得到值、取值2.缺点：①配置复杂②测试不方便③依赖web容器④action是一个单例模式，必须设置为线程安全Struts2工作原理struts2工作原理图1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求2 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）3 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action4 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy5 ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类6 ActionProxy创建一个ActionInvocation的实例。