大包包99
- 浏览: 17554 次
-
最新评论
----------第一天-------- 2
Spring框架的作用和优点： 2
Spring容器： 2
*3）Spring容器的使用方法 3
Spring容器对bean组件的管理： 3
*1)创建Bean对象的方式 3
如何使用Spring容器的ioc机制： 4
1) DI(依赖注入技术) 4
-------第二天------- 9
各种类型数据的注入 9
什么是AOP，解决什么问题 10
5. 通知 11
6. 切入点 11
*1）方法限定表达式 11
*2.类型限定表达式 12
3.Bean的Id或Name名称限定 12
第三天 14
采用AOP记录异常信息。 14
Log4j日志工具 14
Spring注解配置： 15
AOP注解配置 15
-----------Spring整合------- 16
比如对JDBC的整合： 16
对Hibernate进行整合： 16
2.Spring如何与Struts2整合 17
第四天 17
Spring的事务管理： 17
Spring提供一些两种形式事务管理方法： 1）声明式: 17
2）编程式事务管理，了解（基于Java代码实现） 19
Spring的MVC框架： 20
----------第一天--------
总结： struts框架的作用：充当前端控制器。利用struts框架主要的作用是来接收请求，和处理请求。 Hibernate框架的作用，主要是实现对数据库的访问，有3种访问方式，主要是查询语句的使用方式。Spring查找到配置文件中的东西用到的是JAVA的反射技术。
Spring框架的作用和优点：
Spring框架是一个整合其他软件框架的框架，可以在这个平台上使用struts,hibernate，jdbc技术。单独使用这些技术也可以，但是Spring提供了Ioc和aop机制的实现，可以改善程序结构，提高系统的灵活性，便于维护和扩展。替换组件的时候不影响其他的组件。提供一个组件耦合度比较低的平台，主要的优势是使耦合度降至最低，也就是解耦。 Spring是一个开源框架，为javaEE应用提供轻量级的解决方案，提倡“最少侵入”是一个优秀的MVC框架，基于依赖注入的核心机制，基于AOP的声明式事务管理。 在SSH使用中，Spring提供了一个容器，该容器具有IOC和AOP机制，利用这个容器IOC机制管理程序中的DAO，SERVICE等组件，采用AOP机制实现事务，异常等共通处理。 面试的时候介绍这种应用的东西的时候可以先介绍一下相关的理论，然后加上一些代码或者项目经验，比如说在哪个项目中怎么使用了这个组件，这样会让别人更加踏实。
Spring容器：
Spring容器是Spring框架的基础和核心，该容器具有以下功能： ａ可以创建和初始化一个bean组件对象，可以使用单例模式， b 可以管理bean对象的生命周期。 c 可以利用IOC机制建立Bean对象之间的关系。他们之家只有调用关系。 d 可以利用扩展的AOP机制将共通组件给某一批目标组件对象建立关联。（需要单独引入AOP扩展jar包）；2）Spring容器类型可以使BeanFactory或者
ApplicationContext.
--Spring容器实例化
ApplicationContext ac =
new ClasspathXmlApplicationContext(xml配置);
--从Spring容器获取Bean对象
接口类型 变量 = (接口类型)ac.getBean("id属性");
--销毁Spring容器
使用AbstractApplicationContext类型的close();
*3）Spring容器的使用方法
--引入spring核心包
--在src下添加spring配置文件
--在spring配置文件定义Bean组件
<bean id="标识符" class="包名.实现类名">
</bean>
--实例化spring容器，通过容器的
getBean("标识符")方法获取 Spring容器实例化的过程： //获取Spring容器中的CostDAO
//第一步实例化Spring容器
String conf = "applicationContext.xml";
//用于加载src下的xml配置文件
AbstractApplicationContext ac =
new ClassPathXmlApplicationContext(conf);
// FileSystemXmlApplicationContext 用于加载磁盘路径的xml配置
//获取容器中的DAO
CostDAO costDao =
(CostDAO)ac.getBean("costDao");
costDao.save();
costDao.update();
// ac.close();//销毁Spring容器
ApplicationContext里面没有Close()这个方法。
Spring容器对bean组件的管理：
*1)创建Bean对象的方式
Spring可以采用单例和非单例模式创建Bean对象。
默认情况下，采用单例模式创建Bean对象。
在<bean scope="">中利用scope属性控制创建模式。scope="singleton"采用单例模式，
scope="prototype"采用原型(非单例)模式
(在JavaWeb环境中，scope属性值还可以指定request,session等范围，判断是不是同一个request,session)
2)Bean对象的创建时机
如果scope="singleton"，Spring容器实例化时，会自动创建Bean组件对象。（延时机制的时候可以使用）
如果scope="prototype"，Spring容器会在调用getBean方法时创建Bean对象。 属性layz-init=true是表示延时创建
3)Bean对象的初始化和销毁
使用<bean init-method="" destroy-method="">
可以指定Bean对象创建和销毁时触发的方法。
destroy-method只适用于scope="singleton"模式.
当调用applicationcontext.close()时,容器会自动销毁所有单例对象,此时会触发指定destory-method方法。
init-method指定的初始化方法可以在构造方法执行后自动执行。
如何使用Spring容器的ioc机制：
使用接口技术来实现对这个注入对象的控制。实现对两个组件之间的相互调用，这就是IOC的思想，当你改变或者更换其中的一个组件的时候不会影响另外一个组件。 Spring提供的IOC 主要是用于建立两个对象之间的关系，好处是低耦合方式：
1) DI(依赖注入技术)
dependency injection称为依赖注入，就是两个组件之间存在调用关系采用的注入关系。在主要的类中主要使用全局变量和set的方法来实现调用，Spring采用的是DI技术实现了IOC控制思想。DI技术可以分成以下几类： a. setter方式注入,(依靠属性的set方法注入)
B. 构造方法注入：（依靠构造方法的参数注入） c. 接口方式注入：2） IOC思想：inverse of Controller(反向控制或者控制反转)确切来说应该称为控制转移。 控制权：指的是负责对象的创建，初始化以及销毁等工作。组件的替换其实就是要把控制权给换掉。比如：两个组件，当A调用B时，原有方式需要在A里面编写控制权逻辑代码，当需要替换B组时，需要修改控制权逻辑，因此A和B组件的耦合度比较高；采用IOC思想后，就是讲A中的控制权逻辑转移给第三方容器或者框架，由第三方框架负责A/B对象的创建，释放，初始化和关系等指定工作。*3）Action--->DAO采用Spring的IoC方式
--在Action中定义一个DAO接口类型的变量
--在Action中定义一个setter方法，主要作用是接收spring注入进来DAO对象。
--将Action和DAO都交给Spring容器，Action配置如下:
<bean id="action标识符"
class="action实现类">
<!--setter方式注入配置-->
<property name="属性名"
ref="dao定义时的Bean组件Id值">
</property>
</bean>
4）采用构造方式注入重构3示例
--定义带参数构造方法替代setter方法
--定义Action的<bean>时，采用
<constructor-arg>替代<property>配置
<constructor-arg index="构造参数索引"
ref="要注入的Bean对象的id">
</constructor-arg>
补充：单独的测试方法：不需要使用main方法；在每个测试方法前面加一个@Test这个东西，加上去后要引入jar包，运行的时候直接runas就可以，结果的显示界面如果是绿色就是运行成功，如果是红色就表示异常 ，如果是蓝色表示的调用的方法逻辑异常。不影响运行但是运行不出预期的结果。使用asseter来输出。
测试Spring容器创建的bean对象是不是单例模式：取出两个bean对象，判断两个对象是不是相等，相等的话就是同一个是单例。
单例模式容易出现线程并发的问题，如果想改变这个模式的话可以这么改,在xml里面使用属性，scope=“”；里面如果是：protoytpe,是非单例的意思，singleton是单例的意思。工厂对象一般会使用单例模式。
属性init-method=””是初始化方法，不管单例还是不是单例；或者可以直接写在构造方法里面。
属性destroy-method=””;是销毁容器的方法。使用的条件一定是单例模式的对象，而且要有close()才会调用这个方法。
-------第二天-------
各种类型数据的注入
基本类型注入：利用value属性指定，可以注入字符串，数值等简单数据，
Bean对象注入：利用ref属性指定，可以注入一个bean组件对象
集合数据注入：
<bean id="msgBean" scope="singleton"
class="com.tarena.service.MessageBean">
<property name="name" value="露丝"></property>
<property name="age" value="18"></property>
<property name="friends">
<list>
<value>TOM</value>
<value>JACK</value>
<value>张三丰</value>
</list>
</property>
<property name="cities">
<set>
<value>北京</value>
<value>上海</value>
<value>深圳</value>
</set>
</property>
<property name="includeTypes"
value="jpegg,if,jpg">
</property>
<property name="books">
<map>
<entry key="1001" value="Core Java基础"></entry>
<entry key="1002" value="Struts框架详解"></entry>
<entry key="1003" value="编程之美"></entry>
</map>
</property>
<property name="dbParams">
<props>
<prop key="username">root</prop>
<prop key="password">1234</prop>
</props>
</property>
</bean>
什么是AOP，解决什么问题
Aspect Oriented Programming面向方面编程或者是面向切面编程，面向方面编程是以（OOP）面向对象编程为基础，这两种编程思想侧重点不同，OOP侧重于对象，根据需求提炼出对象结构，AOP侧重于方面对象，方面关注的是共通处理部分。例如事务管理，权限控制，日志记录等。把这些共通的处理部分封装成一个类，也就是一个方面组件。 AOP主要是解决一对多调用的问题，一个共通组件被多个目标组件调用，降低组件的关联性。AOP和IOC必须是要在Spring容器里面才有效。
Spring容器AOP的基本思想：1）引入spring-aop开发包
2）编写方面组件，封装共通的处理逻辑
3）在spring配置文件中，定义方面组件，利用aop配置，将方面组件方法和目标组件方法作用在一起。
AOP的相关概念：1）方面(Aspect):方面组件，用于封装共通处理，可以被切入到多个目标对象方法上的组件，只有定义成方面组件才能作用到多个目标对象方法上。2）切入点（Pointcut）:是一个表达式，用于指定哪些组件和方法作为组件的切入目标3）连接点（joinPoint）：切入点是连接点的集合，就是方面组件作用的目标对象的目标方法的作用处，也就是代表方面组件和某一个目标方法的关联点，在获取详细的操作信息的时候会用上，4）通知（advice）:用于指定目标方法和方面组件作用的时机，比如前置通知，before method=’’表示的是先执行方面组件，后执行目标方法。5）目标对象（target）:应用方面组件的对象，或者是与切入点表达式匹配的对象，6）动态代理（autoproty）：Spring采用了动态代理技术事项了AOP控制，如果Spring采用AOP配置后，容器的getbean方法返回的组件对象时一个动态生成类型，也就是动态代理类，代理类负责调用目标对象方法和方面对象方法。Spring采用的动态代理技术有两种：
a.采用cglib.jar工具包
适用于目标组件没有接口实现的情况。
public class $Service$$Enhancer$CGLIB extends原目标组件类型{
//重写目标对象的方法，在重写的方法中调用目标对象和方面组件对象功能}
b.采用JDK Proxy API
适用于目标组件有接口实现的情况。public class $Proxy4 implements 原目标组件接口{
//重写目标接口方法，在重写的方法中调用目标对象和方面组件对象功能}
5. 通知
Spring提供了5种类型的通知。用于指定方面组件在目标方法哪个位置切入。
a.前置通知 <aop:before>
先执行方面组件，再执行目标组件方法
b.后置通知 <aop:after-returning>
先执行目标组件方法，没有异常再执行方面组件。
如果发生异常，不会执行方面组件
c.异常通知 <aop:after-throwing>
当目标方法抛出异常之后，执行方面组件。
d.最终通知 <aop:after>
先执行目标方法，无论有没有异常都执行方面组件
e.环绕通知 <aop:around>
相当于前置+后置通知。在目标方法前和后都执行方面组件
try{
//前置通知切入
//目标组件方法
//后置通知切入
}catch(){
//异常通知切入
}finally{
//最终通知切入
}
6. 切入点
*1）方法限定表达式
可以规定哪些方法被切入方面组件，哪些不被切入
格式如下：
execution(修饰符? 返回类型 方法名(参数)
throws异常? )
示例1：匹配容器中Bean对象的find开始的方法
execution(* find*(..))
示例2：匹配CostServiceImpl类中所有方法
execution(* tarena.service.CostServiceImpl.*(..))
示例3：匹配tarena.service包下所有类的所有方法
execution(* tarena.service.*.*(..))
示例4：匹配tarena.service包及其子包下所有类所有方法
execution(* tarena.service..*.*(..))
示例5：匹配容器Bean对象中的find开始的方法，并且是public void 修饰的
execution(public void find*(..))
*2.类型限定表达式
可以规定哪个类中的所有方法被切入方面组件
格式：within(包名.类型名)
示例1：匹配CostServiceImpl类中所有方法
within(tarena.service.CostServiceImpl)
示例2：匹配tarena.service包下所有类所有方法
within(tarena.service.*)
示例3：匹配tarena.service包及其子包中所有类所有方法
within(tarena.service..*)
3.Bean的Id或Name名称限定
可以按<bean>定义时，id或name属性值匹配
bean(beanIdOrName)
示例1：匹配容器中id=costService的Bean对象
bean(costService)
示例2：匹配容器中id值以Service结尾的对象
bean(*Service)
4.参数类型限定
args(参数类型列表)
示例1：匹配有且只有一个参数，参数类型符合Serializable类型的方法
args(java.io.Serializable)
注意：上述切入点表达式可以联合使用，采用&&,||连接
第三天
主要是使用IOC来实现DAO和ACTION的接藕。
要想达到灵活扩展的功能，使用动态代理的功能，在调用原有的组件功能的基础上再使用AOP机制使用新的组件功能进行扩展。
采用AOP记录异常信息。
编写记录异常信息的方面组件2）编写切入点表达式，指定目标对象3）指定通知类型，目标方法发生异常后执行方面组件。
Log4j日志工具
主要是用于消息输出，可以控制消息输出的级别，输出方式，格式。该工具主要有三类组件构成：
1)Logger日志器
用于将消息分成级别输出。
2)Appender输出器
用于实现消息输出的不同方式。例如控制台，文件等
3)Layout布局器
用于格式化消息内容
Spring注解配置：
组件自动扫描技术：可以自动扫描指定包下的组件，当遇到组件类定义前面有下面注解标注时，会将该组件纳入Spring容器。等价于：<bean>定义 --首先需要在spring配置中开启组件扫描技术
<context:component-scan
base-package="要扫描的包路径"/>
--如果发现类定义前有以下注解标记
@Component ： 各个情况都可使用
@Controller : 建议在Action组件使用
@Service ： 建议在Service组件使用
@Repository : 建议在DAO组件使用
默认将组件扫描到Spring容器，id值使用的是类名首字母小写，如果需要指定id，可以使用@Service("id值")格式定义.
可以使用@Scope注解指定scope=""属性值，使用格式@Scope("prototype")
--如果两个组件之间有注入关系
可以使用@Resource或@Autowired
按类型匹配注入也可以按名称匹配注入，如果按名称匹配注入，@Resource(name="id属性")
在类名的前面加@Service默认的情况下是类名第一个字母小写，如果要自定义的话可以这样@Service（“自定义的ID值”）这种格式定义。默认的情况下单例的，如果要设置成不是单例的，可以在@service这个注解下面加一个@scope（“prototype”）来设定是不是单例的。
声明了全局变量以后使用标注@Resource它会自动从xml文件中寻找相关的bean组件来给它注入值，可以省去set方法，主要是使用在DAO上。使用@Autowired也是可以的，相同的功能。这是使用在两个组件之间存在注入关系的。自定义的时候可以这么定义@Resource(name=”id值”)。
AOP注解配置
--在spring配置中开启AOP注解方式
<aop:aspectj-autoproxy />
--在方面组件中使用以下注解标记…主要是在这样的方面组件里面使用。
======类定义前使用======
@Component //将组件扫描到容器
@Asepect //将组件指定为方面组件
======通知方法前使用======
@Around("切入点表达式") ：环绕通知切入
@Before("切入点表达式") ：前置通知切入
@AfterReturning() ：后置通知切入
@AfterThrowing() : 异常通知切入
@After() : 最终通知切入
-----------Spring整合-------
Spring对数据访问技术的支持
提供了一致的异常处理层次Spring将各种不同访问技术的异常类型封装，统一成了Spring的异常类型，DataAccessException,
提供了编写DAO的一些工具类,提供了DaoSupport,Template这些工具类。比如：采用JDBC技术，提供了jdbcDaoSupport,jdbcTemplate.封装了jdbc的操作。 采用Hibernate技术，提供了HibernateDaoSupport,HibernateTemplate,这几个工具类。
提供了声明式事务管理方法：原理就是采用AOP机制实现了事务管理，在使用的时候只要追加事务配置就可以。一般就是采用的环绕通知。都已经封装好，需要做的配置是切入点和方面组件的声明。
比如对JDBC的整合：
1）引入Spring开发包和配置文件
2）引入JDBC开发包（驱动包）
3）编写数据表对应的实体类POJO
4）编写DAO接口和实现类
实现类 extends JdbcDaoSupport后，可以使用this.getJdbcTemplate方法获取Template对象。利用Template对象方法执行增删改查操作。
5）在Spring容器中定义DAO，注意必须给DAO注入一个dataSource对象。
6）引入dbcp连接池开发包，在Spring容器中定义一个dataSource对象，给DAO注入
对Hibernate进行整合：
给DAO注入比JDBC多了一个sessionfatory;是用来管理事务和数据库连接的。
1)引入开发框架
--Spring开发包
--数据库驱动包和dbcp连接池包
--Hibernate开发包
2)在src下添加Spring的配置文件applicationContext.xml
3)添加实体类POJO和映射描述文件hbm.xml
4)编写DAO接口和HibernateDAO实现类
需要继承HibernateDaoSupport，使用HibernateTemplate工具类完成增删改查操作。
5)需要在applicationContext.xml定义DAO组件，需要给DAO注入sessionFactory;SessionFactory需要注入DataSource.
==============================
JdbcCostDAO(JdbcTemplate)<---DataSourceHibernateCostDAO(HibernateTemplate)
<---SessionFactory<---DataSource
==============================
在使用hibernate的时候要是使用session建议使用回调模式进行调用。
2.Spring如何与Struts2整合
1）将Action纳入到Spring容器中
可以采用扫描注解方式也可以采用XML的<bean>定义。
2）Action使用Service或DAO组件时，采用注入方式，将Service和DAO给Action注入
3）引入一个struts2-spring-plugin-2.1.8.jar开发包
（当发生action请求时，StrutsFilter控制器会通过该开发包去Spring容器寻找Action对象，进行请求处理）
===struts2-spring-plugin-2.1.8.jar原理=====
该组件提供了一个StrutsSpringObjectFactory,当引入该jar包后，会利用StrutsSpringObjectFactory替代原Struts框架中的ObjectFactory负责生成Action对象。
StrutsSpringObjectFactory可以访问Spring容器。
该Factory会按struts.xml中<action>配置的class属性值作为原则寻找Spring容器中的Bean对象。
a.利用class属性当做Bean组件的id值去Spring容器寻找
4-1）修改struts.xml中所有<action>的class属性值,修改成容器中对应Action组件的id值
b.
====================================
5）在web.xml中定义ContextLoaderListener，用于在服务器启动时，实例化Spring容器。
第四天
Spring的事务管理：
Spring提供一些两种形式事务管理方法：1）声明式:
<!-- 声明式事务管理,采用AOP形式切入 -->
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="find*" read-only="true" />
<tx:method name="get*" read-only="true" />
</tx:attributes>
</tx:advice>
<aop:config proxy-target-class="true">
<aop:pointcut id="serviceOperation" expression="within(com.tarena.netctoss.action..*)" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation" />
</aop:config>
1.Spring的事务管理
Spring提供以下两种形式事务管理方法。
*1）声明式事务管理（基于配置实现）
a.基于XML方式配置
--定义事务管理Bean
Hibernate采用HibernateTransactionManager
JDBC采用DataSourceTransactionManager
--定义<tx:advice>事务通知
--定义<aop:config>切入配置
注意：如果将事务切入到Action组件，需要在<aop:config>添加proxy-target-class="true",指定采用CGLIB技术生成动态代理类实现AOP切入。目标对象有接口，不需要指定。
b.基于注解方式配置
--定义事务管理Bean
--在spring配置文件中开启事务注解配置
<tx:annotation-driven proxy-target-class="true"
transaction-manager="txManager"/>
--在目标组件中使用@Transactional注解
定义在方法前：该方法采用指定事务管理
定义在类前：该类所有方法采用指定事务管理
@Transactiona(readOnly=true,
propagation=Propagation.REQUIRED)
2）编程式事务管理，了解（基于Java代码实现）
public class SimpleService implements Service {
public Object someServiceMethod() {
return transactionTemplate.execute(
new TransactionCallback() {
public Object doInTransaction (TransactionStatus status) {
updateOperation1();
return resultOfUpdateOperation2();
}
});
}
}
事务管理中的attributes里面可以有很多个method是用来定义怎么样的事务管理，定义了那个方法怎么管理，propagation=“required”的事务管理方式，name=方法的表达式。Read-only=true只读的方式管理，可以减少数据库的开销； 定义好了以后，就可以把拦截器给去掉，相关的配置也要删掉。事务要是切入action中的时候一定要加一个属性：proxy-target-class=true.指定目标对象时一个类，没有接口，这时动态代理技术的一种实现方法。
Spring中常用事务类型：
REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与REQUIRED类似的操作。
拥有多个可以回滚的保存点，内部回滚不会对外部事务产生影响。只对DataSourceTransactionManager有效
基于注解方式配置：@可以写在类的定义前面也可以写在方法定义前面。在xml里面开启注解：在类的前面加上了以后，相当于整个类里面的所有方法都会在事务管理的范围内，默认的是required.如果要有单独的方法不需要是required的可以在这个方法前面加上注解声明式read-noly的。
使用Spring的优点就在于：
首先，可以使用IoC方式进行注入
其次，可以使用AOP的思想进行切面编程
再次，就是控制事务相对简单
Hibernate延迟加载功能，要再web.xml里面加上opensessionview的文件配置。在spring里面的事务管理和session关闭打开的管理是分开的，所以要使用到session的时候要通过文件配置打开。
Spring的MVC框架：
结构加流程就是这个框架的原理：
Spring MVC结构：控制器：DispatcherServlet,Controller,HandlerMapping,
视图：ViewResolver,jsp模型：ModelAndView,
Spring MVC流程：
MVC框架的主要流程：1. 引入jar包2. 写配置文件3 引入主控制器。
2.Spring整合Hibernate后，为了支持Hibernate延迟加载用法，提供了一个OpenSessionInViewFilter组件，
在web.xml中配置了该过滤器之后，Session关闭会推迟到JSP解析之后。
（默认情况下，HibernateTemplate在执行完其方法时就会关闭Session.）
注意：使用时需要定义在strutsfilter控制器之前。
==================================
3.Spring MVC框架
1）Spring MVC结构
控制器:DispatcherServlet,Controller,
HandlerMapping
视图：ViewResolver，JSP
模型：ModelAndView
2）Spring MVC流程
a.客户端发请求，进入控制器DispatcherServlet
b.控制器调用HandlerMapping组件，根据请求和Controller映射信息，调用相应的Controller组件处理请求
c.控制器执行Controller组件对象的约定处理方法处理请求。在该方法中可以调用DAO,Service等组件
d.Controller处理完毕后，会返回一个ModelAndView对象实例。该实例可以封装模型数据和视图名称。
e.控制器调用ViewResolver组件解析ModelAndVIew对象的信息，找到View组件。
f.在View组件中，利用标签或表达式将数据显示到页面，生成响应内容，给客户输出。
3）Spring MVC入门示例
a.添加Spring核心包和spring-webmvc.jar
b.src添加Spring配置文件applicationContext.xml
c.在web.xml中定义DispatcherServlet控制器
d.定义Controller组件（基于注解）
定义一个业务方法，方法可以有以下格式：
public String f1(){}
public String f2(HttpServletRequest req){}
public String f3(HttpServletRequest req,
HttpServletResponse res){}
public String f4(HttpServletRequest req,
HttpServletResponse res,
HttpSession session){}
//user可以接收表单信息
public String f5(User user){}
//model可以向下一个界面传递模型数据
public String f6(Model model){}
在上述方法上，利用@RequestMapping注解指定该方法和哪一个请求对应
e.基于组件扫描基于将Controller组件扫描到容器
f.在容器中定义一个HandlerMapping组件，采用支持注解配置的AnnotationMethodHandlerAdapter
g.在容器中定义一个ViewResolver
---------------示例spring05_2流程------------------
tologin.do-->DispatcherServlet-->HandlerMapping
-->ToLoginController-->ModelAndView
-->ViewResolver-->WEB-INF/jsp/login.jsp
login.do-->LoginController-->success.jsp(login.jsp)
----------------------------------------------------------
如果想学习Spring MVC建议看Spring05_1基于XML配置，帮助理解。然后采用Spring05_2注解用法使用。
（SpringMVC其他应用可参考Spring中文参考手册）
Spring框架的作用和优点： 2
Spring容器： 2
*3）Spring容器的使用方法 3
Spring容器对bean组件的管理： 3
*1)创建Bean对象的方式 3
如何使用Spring容器的ioc机制： 4
1) DI(依赖注入技术) 4
-------第二天------- 9
各种类型数据的注入 9
什么是AOP，解决什么问题 10
5. 通知 11
6. 切入点 11
*1）方法限定表达式 11
*2.类型限定表达式 12
3.Bean的Id或Name名称限定 12
第三天 14
采用AOP记录异常信息。 14
Log4j日志工具 14
Spring注解配置： 15
AOP注解配置 15
-----------Spring整合------- 16
比如对JDBC的整合： 16
对Hibernate进行整合： 16
2.Spring如何与Struts2整合 17
第四天 17
Spring的事务管理： 17
Spring提供一些两种形式事务管理方法： 1）声明式: 17
2）编程式事务管理，了解（基于Java代码实现） 19
Spring的MVC框架： 20
----------第一天--------
总结： struts框架的作用：充当前端控制器。利用struts框架主要的作用是来接收请求，和处理请求。 Hibernate框架的作用，主要是实现对数据库的访问，有3种访问方式，主要是查询语句的使用方式。Spring查找到配置文件中的东西用到的是JAVA的反射技术。
Spring框架的作用和优点：
Spring框架是一个整合其他软件框架的框架，可以在这个平台上使用struts,hibernate，jdbc技术。单独使用这些技术也可以，但是Spring提供了Ioc和aop机制的实现，可以改善程序结构，提高系统的灵活性，便于维护和扩展。替换组件的时候不影响其他的组件。提供一个组件耦合度比较低的平台，主要的优势是使耦合度降至最低，也就是解耦。 Spring是一个开源框架，为javaEE应用提供轻量级的解决方案，提倡“最少侵入”是一个优秀的MVC框架，基于依赖注入的核心机制，基于AOP的声明式事务管理。 在SSH使用中，Spring提供了一个容器，该容器具有IOC和AOP机制，利用这个容器IOC机制管理程序中的DAO，SERVICE等组件，采用AOP机制实现事务，异常等共通处理。 面试的时候介绍这种应用的东西的时候可以先介绍一下相关的理论，然后加上一些代码或者项目经验，比如说在哪个项目中怎么使用了这个组件，这样会让别人更加踏实。
Spring容器：
Spring容器是Spring框架的基础和核心，该容器具有以下功能： ａ可以创建和初始化一个bean组件对象，可以使用单例模式， b 可以管理bean对象的生命周期。 c 可以利用IOC机制建立Bean对象之间的关系。他们之家只有调用关系。 d 可以利用扩展的AOP机制将共通组件给某一批目标组件对象建立关联。（需要单独引入AOP扩展jar包）；2）Spring容器类型可以使BeanFactory或者
ApplicationContext.
--Spring容器实例化
ApplicationContext ac =
new ClasspathXmlApplicationContext(xml配置);
--从Spring容器获取Bean对象
接口类型 变量 = (接口类型)ac.getBean("id属性");
--销毁Spring容器
使用AbstractApplicationContext类型的close();
*3）Spring容器的使用方法
--引入spring核心包
--在src下添加spring配置文件
--在spring配置文件定义Bean组件
<bean id="标识符" class="包名.实现类名">
</bean>
--实例化spring容器，通过容器的
getBean("标识符")方法获取 Spring容器实例化的过程： //获取Spring容器中的CostDAO
//第一步实例化Spring容器
String conf = "applicationContext.xml";
//用于加载src下的xml配置文件
AbstractApplicationContext ac =
new ClassPathXmlApplicationContext(conf);
// FileSystemXmlApplicationContext 用于加载磁盘路径的xml配置
//获取容器中的DAO
CostDAO costDao =
(CostDAO)ac.getBean("costDao");
costDao.save();
costDao.update();
// ac.close();//销毁Spring容器
ApplicationContext里面没有Close()这个方法。
Spring容器对bean组件的管理：
*1)创建Bean对象的方式
Spring可以采用单例和非单例模式创建Bean对象。
默认情况下，采用单例模式创建Bean对象。
在<bean scope="">中利用scope属性控制创建模式。scope="singleton"采用单例模式，
scope="prototype"采用原型(非单例)模式
(在JavaWeb环境中，scope属性值还可以指定request,session等范围，判断是不是同一个request,session)
2)Bean对象的创建时机
如果scope="singleton"，Spring容器实例化时，会自动创建Bean组件对象。（延时机制的时候可以使用）
如果scope="prototype"，Spring容器会在调用getBean方法时创建Bean对象。 属性layz-init=true是表示延时创建
3)Bean对象的初始化和销毁
使用<bean init-method="" destroy-method="">
可以指定Bean对象创建和销毁时触发的方法。
destroy-method只适用于scope="singleton"模式.
当调用applicationcontext.close()时,容器会自动销毁所有单例对象,此时会触发指定destory-method方法。
init-method指定的初始化方法可以在构造方法执行后自动执行。
如何使用Spring容器的ioc机制：
使用接口技术来实现对这个注入对象的控制。实现对两个组件之间的相互调用，这就是IOC的思想，当你改变或者更换其中的一个组件的时候不会影响另外一个组件。 Spring提供的IOC 主要是用于建立两个对象之间的关系，好处是低耦合方式：
1) DI(依赖注入技术)
dependency injection称为依赖注入，就是两个组件之间存在调用关系采用的注入关系。在主要的类中主要使用全局变量和set的方法来实现调用，Spring采用的是DI技术实现了IOC控制思想。DI技术可以分成以下几类： a. setter方式注入,(依靠属性的set方法注入)
B. 构造方法注入：（依靠构造方法的参数注入） c. 接口方式注入：2） IOC思想：inverse of Controller(反向控制或者控制反转)确切来说应该称为控制转移。 控制权：指的是负责对象的创建，初始化以及销毁等工作。组件的替换其实就是要把控制权给换掉。比如：两个组件，当A调用B时，原有方式需要在A里面编写控制权逻辑代码，当需要替换B组时，需要修改控制权逻辑，因此A和B组件的耦合度比较高；采用IOC思想后，就是讲A中的控制权逻辑转移给第三方容器或者框架，由第三方框架负责A/B对象的创建，释放，初始化和关系等指定工作。*3）Action--->DAO采用Spring的IoC方式
--在Action中定义一个DAO接口类型的变量
--在Action中定义一个setter方法，主要作用是接收spring注入进来DAO对象。
--将Action和DAO都交给Spring容器，Action配置如下:
<bean id="action标识符"
class="action实现类">
<!--setter方式注入配置-->
<property name="属性名"
ref="dao定义时的Bean组件Id值">
</property>
</bean>
4）采用构造方式注入重构3示例
--定义带参数构造方法替代setter方法
--定义Action的<bean>时，采用
<constructor-arg>替代<property>配置
<constructor-arg index="构造参数索引"
ref="要注入的Bean对象的id">
</constructor-arg>
补充：单独的测试方法：不需要使用main方法；在每个测试方法前面加一个@Test这个东西，加上去后要引入jar包，运行的时候直接runas就可以，结果的显示界面如果是绿色就是运行成功，如果是红色就表示异常 ，如果是蓝色表示的调用的方法逻辑异常。不影响运行但是运行不出预期的结果。使用asseter来输出。
测试Spring容器创建的bean对象是不是单例模式：取出两个bean对象，判断两个对象是不是相等，相等的话就是同一个是单例。
单例模式容易出现线程并发的问题，如果想改变这个模式的话可以这么改,在xml里面使用属性，scope=“”；里面如果是：protoytpe,是非单例的意思，singleton是单例的意思。工厂对象一般会使用单例模式。
属性init-method=””是初始化方法，不管单例还是不是单例；或者可以直接写在构造方法里面。
属性destroy-method=””;是销毁容器的方法。使用的条件一定是单例模式的对象，而且要有close()才会调用这个方法。
-------第二天-------
各种类型数据的注入
基本类型注入：利用value属性指定，可以注入字符串，数值等简单数据，
Bean对象注入：利用ref属性指定，可以注入一个bean组件对象
集合数据注入：
<bean id="msgBean" scope="singleton"
class="com.tarena.service.MessageBean">
<property name="name" value="露丝"></property>
<property name="age" value="18"></property>
<property name="friends">
<list>
<value>TOM</value>
<value>JACK</value>
<value>张三丰</value>
</list>
</property>
<property name="cities">
<set>
<value>北京</value>
<value>上海</value>
<value>深圳</value>
</set>
</property>
<property name="includeTypes"
value="jpegg,if,jpg">
</property>
<property name="books">
<map>
<entry key="1001" value="Core Java基础"></entry>
<entry key="1002" value="Struts框架详解"></entry>
<entry key="1003" value="编程之美"></entry>
</map>
</property>
<property name="dbParams">
<props>
<prop key="username">root</prop>
<prop key="password">1234</prop>
</props>
</property>
</bean>
什么是AOP，解决什么问题
Aspect Oriented Programming面向方面编程或者是面向切面编程，面向方面编程是以（OOP）面向对象编程为基础，这两种编程思想侧重点不同，OOP侧重于对象，根据需求提炼出对象结构，AOP侧重于方面对象，方面关注的是共通处理部分。例如事务管理，权限控制，日志记录等。把这些共通的处理部分封装成一个类，也就是一个方面组件。 AOP主要是解决一对多调用的问题，一个共通组件被多个目标组件调用，降低组件的关联性。AOP和IOC必须是要在Spring容器里面才有效。
Spring容器AOP的基本思想：1）引入spring-aop开发包
2）编写方面组件，封装共通的处理逻辑
3）在spring配置文件中，定义方面组件，利用aop配置，将方面组件方法和目标组件方法作用在一起。
AOP的相关概念：1）方面(Aspect):方面组件，用于封装共通处理，可以被切入到多个目标对象方法上的组件，只有定义成方面组件才能作用到多个目标对象方法上。2）切入点（Pointcut）:是一个表达式，用于指定哪些组件和方法作为组件的切入目标3）连接点（joinPoint）：切入点是连接点的集合，就是方面组件作用的目标对象的目标方法的作用处，也就是代表方面组件和某一个目标方法的关联点，在获取详细的操作信息的时候会用上，4）通知（advice）:用于指定目标方法和方面组件作用的时机，比如前置通知，before method=’’表示的是先执行方面组件，后执行目标方法。5）目标对象（target）:应用方面组件的对象，或者是与切入点表达式匹配的对象，6）动态代理（autoproty）：Spring采用了动态代理技术事项了AOP控制，如果Spring采用AOP配置后，容器的getbean方法返回的组件对象时一个动态生成类型，也就是动态代理类，代理类负责调用目标对象方法和方面对象方法。Spring采用的动态代理技术有两种：
a.采用cglib.jar工具包
适用于目标组件没有接口实现的情况。
public class $Service$$Enhancer$CGLIB extends原目标组件类型{
//重写目标对象的方法，在重写的方法中调用目标对象和方面组件对象功能}
b.采用JDK Proxy API
适用于目标组件有接口实现的情况。public class $Proxy4 implements 原目标组件接口{
//重写目标接口方法，在重写的方法中调用目标对象和方面组件对象功能}
5. 通知
Spring提供了5种类型的通知。用于指定方面组件在目标方法哪个位置切入。
a.前置通知 <aop:before>
先执行方面组件，再执行目标组件方法
b.后置通知 <aop:after-returning>
先执行目标组件方法，没有异常再执行方面组件。
如果发生异常，不会执行方面组件
c.异常通知 <aop:after-throwing>
当目标方法抛出异常之后，执行方面组件。
d.最终通知 <aop:after>
先执行目标方法，无论有没有异常都执行方面组件
e.环绕通知 <aop:around>
相当于前置+后置通知。在目标方法前和后都执行方面组件
try{
//前置通知切入
//目标组件方法
//后置通知切入
}catch(){
//异常通知切入
}finally{
//最终通知切入
}
6. 切入点
*1）方法限定表达式
可以规定哪些方法被切入方面组件，哪些不被切入
格式如下：
execution(修饰符? 返回类型 方法名(参数)
throws异常? )
示例1：匹配容器中Bean对象的find开始的方法
execution(* find*(..))
示例2：匹配CostServiceImpl类中所有方法
execution(* tarena.service.CostServiceImpl.*(..))
示例3：匹配tarena.service包下所有类的所有方法
execution(* tarena.service.*.*(..))
示例4：匹配tarena.service包及其子包下所有类所有方法
execution(* tarena.service..*.*(..))
示例5：匹配容器Bean对象中的find开始的方法，并且是public void 修饰的
execution(public void find*(..))
*2.类型限定表达式
可以规定哪个类中的所有方法被切入方面组件
格式：within(包名.类型名)
示例1：匹配CostServiceImpl类中所有方法
within(tarena.service.CostServiceImpl)
示例2：匹配tarena.service包下所有类所有方法
within(tarena.service.*)
示例3：匹配tarena.service包及其子包中所有类所有方法
within(tarena.service..*)
3.Bean的Id或Name名称限定
可以按<bean>定义时，id或name属性值匹配
bean(beanIdOrName)
示例1：匹配容器中id=costService的Bean对象
bean(costService)
示例2：匹配容器中id值以Service结尾的对象
bean(*Service)
4.参数类型限定
args(参数类型列表)
示例1：匹配有且只有一个参数，参数类型符合Serializable类型的方法
args(java.io.Serializable)
注意：上述切入点表达式可以联合使用，采用&&,||连接
第三天
主要是使用IOC来实现DAO和ACTION的接藕。
要想达到灵活扩展的功能，使用动态代理的功能，在调用原有的组件功能的基础上再使用AOP机制使用新的组件功能进行扩展。
采用AOP记录异常信息。
编写记录异常信息的方面组件2）编写切入点表达式，指定目标对象3）指定通知类型，目标方法发生异常后执行方面组件。
Log4j日志工具
主要是用于消息输出，可以控制消息输出的级别，输出方式，格式。该工具主要有三类组件构成：
1)Logger日志器
用于将消息分成级别输出。
2)Appender输出器
用于实现消息输出的不同方式。例如控制台，文件等
3)Layout布局器
用于格式化消息内容
Spring注解配置：
组件自动扫描技术：可以自动扫描指定包下的组件，当遇到组件类定义前面有下面注解标注时，会将该组件纳入Spring容器。等价于：<bean>定义 --首先需要在spring配置中开启组件扫描技术
<context:component-scan
base-package="要扫描的包路径"/>
--如果发现类定义前有以下注解标记
@Component ： 各个情况都可使用
@Controller : 建议在Action组件使用
@Service ： 建议在Service组件使用
@Repository : 建议在DAO组件使用
默认将组件扫描到Spring容器，id值使用的是类名首字母小写，如果需要指定id，可以使用@Service("id值")格式定义.
可以使用@Scope注解指定scope=""属性值，使用格式@Scope("prototype")
--如果两个组件之间有注入关系
可以使用@Resource或@Autowired
按类型匹配注入也可以按名称匹配注入，如果按名称匹配注入，@Resource(name="id属性")
在类名的前面加@Service默认的情况下是类名第一个字母小写，如果要自定义的话可以这样@Service（“自定义的ID值”）这种格式定义。默认的情况下单例的，如果要设置成不是单例的，可以在@service这个注解下面加一个@scope（“prototype”）来设定是不是单例的。
声明了全局变量以后使用标注@Resource它会自动从xml文件中寻找相关的bean组件来给它注入值，可以省去set方法，主要是使用在DAO上。使用@Autowired也是可以的，相同的功能。这是使用在两个组件之间存在注入关系的。自定义的时候可以这么定义@Resource(name=”id值”)。
AOP注解配置
--在spring配置中开启AOP注解方式
<aop:aspectj-autoproxy />
--在方面组件中使用以下注解标记…主要是在这样的方面组件里面使用。
======类定义前使用======
@Component //将组件扫描到容器
@Asepect //将组件指定为方面组件
======通知方法前使用======
@Around("切入点表达式") ：环绕通知切入
@Before("切入点表达式") ：前置通知切入
@AfterReturning() ：后置通知切入
@AfterThrowing() : 异常通知切入
@After() : 最终通知切入
-----------Spring整合-------
Spring对数据访问技术的支持
提供了一致的异常处理层次Spring将各种不同访问技术的异常类型封装，统一成了Spring的异常类型，DataAccessException,
提供了编写DAO的一些工具类,提供了DaoSupport,Template这些工具类。比如：采用JDBC技术，提供了jdbcDaoSupport,jdbcTemplate.封装了jdbc的操作。 采用Hibernate技术，提供了HibernateDaoSupport,HibernateTemplate,这几个工具类。
提供了声明式事务管理方法：原理就是采用AOP机制实现了事务管理，在使用的时候只要追加事务配置就可以。一般就是采用的环绕通知。都已经封装好，需要做的配置是切入点和方面组件的声明。
比如对JDBC的整合：
1）引入Spring开发包和配置文件
2）引入JDBC开发包（驱动包）
3）编写数据表对应的实体类POJO
4）编写DAO接口和实现类
实现类 extends JdbcDaoSupport后，可以使用this.getJdbcTemplate方法获取Template对象。利用Template对象方法执行增删改查操作。
5）在Spring容器中定义DAO，注意必须给DAO注入一个dataSource对象。
6）引入dbcp连接池开发包，在Spring容器中定义一个dataSource对象，给DAO注入
对Hibernate进行整合：
给DAO注入比JDBC多了一个sessionfatory;是用来管理事务和数据库连接的。
1)引入开发框架
--Spring开发包
--数据库驱动包和dbcp连接池包
--Hibernate开发包
2)在src下添加Spring的配置文件applicationContext.xml
3)添加实体类POJO和映射描述文件hbm.xml
4)编写DAO接口和HibernateDAO实现类
需要继承HibernateDaoSupport，使用HibernateTemplate工具类完成增删改查操作。
5)需要在applicationContext.xml定义DAO组件，需要给DAO注入sessionFactory;SessionFactory需要注入DataSource.
==============================
JdbcCostDAO(JdbcTemplate)<---DataSourceHibernateCostDAO(HibernateTemplate)
<---SessionFactory<---DataSource
==============================
在使用hibernate的时候要是使用session建议使用回调模式进行调用。
2.Spring如何与Struts2整合
1）将Action纳入到Spring容器中
可以采用扫描注解方式也可以采用XML的<bean>定义。
2）Action使用Service或DAO组件时，采用注入方式，将Service和DAO给Action注入
3）引入一个struts2-spring-plugin-2.1.8.jar开发包
（当发生action请求时，StrutsFilter控制器会通过该开发包去Spring容器寻找Action对象，进行请求处理）
===struts2-spring-plugin-2.1.8.jar原理=====
该组件提供了一个StrutsSpringObjectFactory,当引入该jar包后，会利用StrutsSpringObjectFactory替代原Struts框架中的ObjectFactory负责生成Action对象。
StrutsSpringObjectFactory可以访问Spring容器。
该Factory会按struts.xml中<action>配置的class属性值作为原则寻找Spring容器中的Bean对象。
a.利用class属性当做Bean组件的id值去Spring容器寻找
4-1）修改struts.xml中所有<action>的class属性值,修改成容器中对应Action组件的id值
b.
====================================
5）在web.xml中定义ContextLoaderListener，用于在服务器启动时，实例化Spring容器。
第四天
Spring的事务管理：
Spring提供一些两种形式事务管理方法：1）声明式:
<!-- 声明式事务管理,采用AOP形式切入 -->
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="find*" read-only="true" />
<tx:method name="get*" read-only="true" />
</tx:attributes>
</tx:advice>
<aop:config proxy-target-class="true">
<aop:pointcut id="serviceOperation" expression="within(com.tarena.netctoss.action..*)" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation" />
</aop:config>
1.Spring的事务管理
Spring提供以下两种形式事务管理方法。
*1）声明式事务管理（基于配置实现）
a.基于XML方式配置
--定义事务管理Bean
Hibernate采用HibernateTransactionManager
JDBC采用DataSourceTransactionManager
--定义<tx:advice>事务通知
--定义<aop:config>切入配置
注意：如果将事务切入到Action组件，需要在<aop:config>添加proxy-target-class="true",指定采用CGLIB技术生成动态代理类实现AOP切入。目标对象有接口，不需要指定。
b.基于注解方式配置
--定义事务管理Bean
--在spring配置文件中开启事务注解配置
<tx:annotation-driven proxy-target-class="true"
transaction-manager="txManager"/>
--在目标组件中使用@Transactional注解
定义在方法前：该方法采用指定事务管理
定义在类前：该类所有方法采用指定事务管理
@Transactiona(readOnly=true,
propagation=Propagation.REQUIRED)
2）编程式事务管理，了解（基于Java代码实现）
public class SimpleService implements Service {
public Object someServiceMethod() {
return transactionTemplate.execute(
new TransactionCallback() {
public Object doInTransaction (TransactionStatus status) {
updateOperation1();
return resultOfUpdateOperation2();
}
});
}
}
事务管理中的attributes里面可以有很多个method是用来定义怎么样的事务管理，定义了那个方法怎么管理，propagation=“required”的事务管理方式，name=方法的表达式。Read-only=true只读的方式管理，可以减少数据库的开销； 定义好了以后，就可以把拦截器给去掉，相关的配置也要删掉。事务要是切入action中的时候一定要加一个属性：proxy-target-class=true.指定目标对象时一个类，没有接口，这时动态代理技术的一种实现方法。
Spring中常用事务类型：
REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与REQUIRED类似的操作。
拥有多个可以回滚的保存点，内部回滚不会对外部事务产生影响。只对DataSourceTransactionManager有效
基于注解方式配置：@可以写在类的定义前面也可以写在方法定义前面。在xml里面开启注解：在类的前面加上了以后，相当于整个类里面的所有方法都会在事务管理的范围内，默认的是required.如果要有单独的方法不需要是required的可以在这个方法前面加上注解声明式read-noly的。
使用Spring的优点就在于：
首先，可以使用IoC方式进行注入
其次，可以使用AOP的思想进行切面编程
再次，就是控制事务相对简单
Hibernate延迟加载功能，要再web.xml里面加上opensessionview的文件配置。在spring里面的事务管理和session关闭打开的管理是分开的，所以要使用到session的时候要通过文件配置打开。
Spring的MVC框架：
结构加流程就是这个框架的原理：
Spring MVC结构：控制器：DispatcherServlet,Controller,HandlerMapping,
视图：ViewResolver,jsp模型：ModelAndView,
Spring MVC流程：
MVC框架的主要流程：1. 引入jar包2. 写配置文件3 引入主控制器。
2.Spring整合Hibernate后，为了支持Hibernate延迟加载用法，提供了一个OpenSessionInViewFilter组件，
在web.xml中配置了该过滤器之后，Session关闭会推迟到JSP解析之后。
（默认情况下，HibernateTemplate在执行完其方法时就会关闭Session.）
注意：使用时需要定义在strutsfilter控制器之前。
==================================
3.Spring MVC框架
1）Spring MVC结构
控制器:DispatcherServlet,Controller,
HandlerMapping
视图：ViewResolver，JSP
模型：ModelAndView
2）Spring MVC流程
a.客户端发请求，进入控制器DispatcherServlet
b.控制器调用HandlerMapping组件，根据请求和Controller映射信息，调用相应的Controller组件处理请求
c.控制器执行Controller组件对象的约定处理方法处理请求。在该方法中可以调用DAO,Service等组件
d.Controller处理完毕后，会返回一个ModelAndView对象实例。该实例可以封装模型数据和视图名称。
e.控制器调用ViewResolver组件解析ModelAndVIew对象的信息，找到View组件。
f.在View组件中，利用标签或表达式将数据显示到页面，生成响应内容，给客户输出。
3）Spring MVC入门示例
a.添加Spring核心包和spring-webmvc.jar
b.src添加Spring配置文件applicationContext.xml
c.在web.xml中定义DispatcherServlet控制器
d.定义Controller组件（基于注解）
定义一个业务方法，方法可以有以下格式：
public String f1(){}
public String f2(HttpServletRequest req){}
public String f3(HttpServletRequest req,
HttpServletResponse res){}
public String f4(HttpServletRequest req,
HttpServletResponse res,
HttpSession session){}
//user可以接收表单信息
public String f5(User user){}
//model可以向下一个界面传递模型数据
public String f6(Model model){}
在上述方法上，利用@RequestMapping注解指定该方法和哪一个请求对应
e.基于组件扫描基于将Controller组件扫描到容器
f.在容器中定义一个HandlerMapping组件，采用支持注解配置的AnnotationMethodHandlerAdapter
g.在容器中定义一个ViewResolver
---------------示例spring05_2流程------------------
tologin.do-->DispatcherServlet-->HandlerMapping
-->ToLoginController-->ModelAndView
-->ViewResolver-->WEB-INF/jsp/login.jsp
login.do-->LoginController-->success.jsp(login.jsp)
----------------------------------------------------------
如果想学习Spring MVC建议看Spring05_1基于XML配置，帮助理解。然后采用Spring05_2注解用法使用。
（SpringMVC其他应用可参考Spring中文参考手册）
分享到：
发表评论
相关推荐
Java Spring框架学习笔记（内附源码）.pdf
spring学习笔记
马士兵老师spring框架学习笔记
spring框架学习笔记(全).pdf
最新spring框架学习笔记(全)资料.pdf最新spring框架学习笔记(全)资料.pdf
最新spring框架学习笔记(全)资料 (2).pdf最新spring框架学习笔记(全)资料 (2).pdf
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java...
动力节点王鹤老师的Spring框架教程配套笔记分享
Spring框架的学习笔记，包括了springIOC，spirng注入，springAoP，SpringJdbc模板的使用，Spring声明式事务。
spring框架整体知识点整理，代码样例
Spring框架 IoC学习笔记，对Spring框架学习中各种问题的记录。
java框架学习笔记spring笔记
spring学习笔记spring学习笔记spring学习笔记spring学习笔记spring学习笔记spring学习笔记spring学习笔记spring学习笔记
SSH框架学习笔记,提供给初学者使用。 1. Struts简介 2. spring
spring框架学习笔记，整理了spring框架技术的主要技术点，适合初学者
spring5框架简单的学习笔记，自己后面用来参考复习所用