spring
1 什么是spring ?
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.
spring的设计思想是，单例模式和工厂模式
2 spring的四大特点（优点）
轻量级,低侵入的设计
Spring的DI机制降低了业务对象替换的复杂性
spring不依赖于web容器，独立于各种应用服务器， Write Once,Run Anywhere（一次编译到处运行）
高度开放性：Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部，它的架构仍然是内在稳定的
3 spring的组成部分 七大模块
Spring Core：Spring的基石，提供了Spring的最主要的核心机制：控制反转和依赖注入
Spring Context：提供了Spring的上下文信息，如：国际化，验证等
Spring Web支持：简化了处理多部分请求
Spring MVC框架支持：一个全功能的构建 Web 应用程序的 MVC 实现，MVC 容纳了大量视图技术，其中包括 JSP、Velocity等。
Spring Dao支持：Spring的Dao支持大大的简化了JDBC操作数据库所带来的繁琐
Spring ORM支持 pring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。
所有这些都遵从Spring的通用事务和DAO异常层结构。
Spring AOP：面向方面编程，提供了事务，日志，权限，安全等处理机制
具体解释
Spring 核心容器(Core):提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它
是工厂模式的实现。BeanFactory使用控制反转(Ioc)模式将应用程序的配置和依赖性规范与实际的应
用代码程序分开。
Spring AOP:通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序
中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理
集成到应用程序中。
Spring ORM:Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。
Spring DAO:JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量(例如，打开和关系连接)。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。
Spring WEB:Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用
程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求
及将请求参数绑定到域对象的工作
Spring上下文(Context):Spring上下文是一个配置文件，向Spring框架提供上下文信息。
Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。
Spring MVC:Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，
MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol
4 spring的核心机制
1）.控制反转（IoC/Inverse Of Control）:调用者不再创建被调用者的实例，由spring框架实现（容器创建）所以称为控制反转。
2）.依赖注入(DI/Dependence injection) :创建好实例后再注入调用者称为依赖注入。
当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，
在传统的程序设计过程中，通常由调用者来创建被调用者的实例, 但在Spring里，创建被调用者的工
作不再由调用者来完成，因此称为控制反转; 创建被调用者 实例的工作通常由Spring容器来完成，
然后注入调用者，因此也称为依赖注入
什么是ioc容器
bean工厂(BeanFactory) 和 应用上下文(Application Context)
在Spring中，BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
BeanFactory
|
|
ApplicationContext(国际化)
/ \
/ \
FileSystemXmlApplicationContext ClassPathXmlApplicationContext
常用有三种方式可以得到BeanFactory ，从而bean实例，并进行调用
// InputStream is = new FileInputStream("beans.xml");
// InputStreamResource isr = new InputStreamResource(is);
// BeanFactory beanFactory = new XmlBeanFactory(isr);
//
// Spring给出一些BeanFactory的实现类，其中最为常用的是XmlBeanFactory。
// 1、通过文件系统
// Resource res = new FileSystemResource("src/beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
// 2、通过类路径（class路径 ./表示上级目录）
// ClassPathResource res = new ClassPathResource("./beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
// 3、通过ApplicationContext加载（ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext）
// ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
// new String[] {"./beans.xml"});
// BeanFactory beanFactory = (BeanFactory) appContext;
//
// ClassPathResource res = new ClassPathResource("./beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
或者 ApplicationContext ctx=new FileSystemXmlApplicationContext("src/bean.xml");
ApplicationContext增加功能 1国际化2事件支持
国际化测试
(1)bean配置
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>message</value>
<!-- 如果有多个资源文件，全部列在此处-->
</list>
</property>
</bean>
（2）
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
String[] a = {"读者"};
String hello = ctx.getMessage("hello",a,Locale.ENGLISH);//英文
Object[] b = {new Date()};
String now = ctx.getMessage("hello",b,Locale.getDefault());//默认
System.out.println(hello);
System.out.println(now);
5 简单测试BeanFactory
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="aaa" class="包名.类名"/>
</beans>
测试 FileSystemXmlApplicationContext默认从项目目录寻找bean配置文件xml
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/bean.xml");
Test t=(Test)ctx.getBean("aaa");
System.out.println(t.getName());
依赖注入的优点，代码将更加清晰，Spring管理bean的灵巧性, bean与bean之间的依赖关系放在配置文件里组织，
不再担心对象之间的依赖关系之后，实现更高层次的松耦合将易如反掌
依赖注入的方式 （为什么叫依赖注入 类的四种关系 ）
(1)set注入(2)构造注入(3)lookup方法注入
setter注入实例
<bean id="aaa" class="包名.类名">
<property name="属性名">
<ref local="另一个bean id"/>//local与bean的区别
</property>
</bean>
//local与bean的区别 local：当前xml bean：整个spring容器
构造注入实例 提供构造方法（注入的实例参数） 要提供无参的构造方法
<bean id="aaa" class="包名.类名">
<constructor-arg><ref bean="steelAxe"/></constructor-arg>
</bean>
(3)lookup方法注入(依赖注入的bean每次都创建一个新实例)
这种方法主要是用在Singleton的Object中使用非Singleton的Bean时，
通过lookup-method的那个方法来取得非Singleton的Bean。一般用的不多，在用这种定义之前最佳想明白你的需求。
1 Singleton的Object 中提供一个抽象方法，返回非Singleton的Bean，此时Singleton的类变成抽象类 如
public abstract class Test//Singleton的Bean {
TestBean tb;//非Singleton的Bean时
public TestBean getTb() {
return tb;
}
public void setTb(TestBean tb) {
this.tb = tb;
}
public abstract TestBean createXxx();
}
2 配置xml
<bean id="testbean" class="com.TestBean" singleton="false"/>//注意singleton="false"
<bean id="test" class="com.Test">
<property name="tb"> <ref local="testbean"/></property>//注意这个依然不能少
<lookup-method name="createXxx" bean="testbean"/>
</bean>
3 测试
Test t=(Test)ctx.getBean("test");
System.out.println("不使用lookup-method注入");
TestBean tb1=t.getTb();
TestBean tb2=t.getTb();
System.out.println(tb1==tb2);
System.out.println("使用lookup-method注入");
TestBean tb3=t.createXxx();
TestBean tb4=t.createXxx();
System.out.println(tb3==tb4);
结果
不使用lookup-method注入
true
使用lookup-method注入
false
注入其他属性例子
<beans>
<bean id="aaa" class="包名.类名"/>
<bean id="bbb" class="lee.Chinese">
<property name="schools">
<list>
<value>小学</value>
<value>中学</value>
<value>大学</value>
</list>
</property>
<property name="score">
<map>
<entry key="数学">
<value>87</value>
</entry>
<entry key="英语">
<value>89</value>
</entry>
<entry key="语文">
<value>82</value>
</entry>
</map>
</property>
<property name="health">
<props>
<prop key="血压">正常</prop>
<prop key="身高">175</prop>
</props>
</property>
<property name="axes">
<set>
<value>xxx</value>
<bean class="包名.类名"/>
<ref local="另外一个bean id"/>
</set>
</property>
</bean>
</beans>
上述中的health指的是Properties属性类
private Properties health = new Properties();
测试 Spring的DI机制降低了业务对象替换的复杂性 面向接口编程的好处 灵活配置
6 spring bean的实例 创建的几种方式
（1）构造器 单例思想
（2）静态工厂（静态方法创建）
静态方法名(iint type)
<bean id="xxx" class="包名.类名（工厂类)" factory-method="静态方法名">
<constructor-arg value="1"></constructor-arg>
</bean>
创建同一接口下不同实例
（3）工厂方法（非静态方法创建）
<bean id="aaa" class="com.PersonFactory(工厂类)">
<property name="type"><value>1</value></property>
</bean>
<bean id="xxx" factory-bean="工厂bean id" factory-method="非静态方法名">
7 自动装配
有两个bean A与B
B作为A的一个属性，当我们没有通过setter注入或者构造注入B实例时，我们可以在A bean中指定autowire属性，
让它在spring容器个根据不同方式自动寻找b实例
自动装配的优缺点：
优点：自动装配能显著减少配置的数量，自动装配可以使配置与java代码同步更新
缺点：Spring会尽量避免在装配不明确的时候进行猜测，容器中可能存在多个bean定义跟自动装配的
setter方法和构造器参数类型匹配
byName（用于set注入） 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如，在bean定义中将autowire设置为by name，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定义，并用它来装配给master属性。
byType 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通过设置dependency-check="objects"让Spring抛出异常。
constructor 与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
autodetect 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
在用byType时候，如果没有匹配的bean 可测试dependency-check="objects"让Spring抛出异常
8 spring框架中bean的生命周期?
(1) bean定义
在配置文件里面用<bean></bean>来进行定义。
(2) bean初始化
有两种方式初始化: 也可同时使用。参数指定的后执行
A.在配置文件中通过指定init-method属性来完成
B.实现org.springframwork.beans.factory.InitializingBean接口 实现afterPropertiesSet()方法
(3) bean调用
有三种方式可以得到bean实例，并进行调用
(4) bean销毁
销毁有两种方式。也可同时使用参数指定的销毁方法后运行
A.使用配置文件指定的destroy-method属性
B.实现org.springframwork.bean.factory.DisposableBean接口 实现destroy()方法
可以通过调用ConfigurableListableBeanFactory(XmlBeanFactory)里的destroySingletons销毁单例对象，测试destroy()方
ConfigurableListableBeanFactory beanFactory =
new XmlBeanFactory(new FileSystemResource("src/bean.xml"));
beanFactory.destroySingletons();
}
是的， 当调用beanFactory.destroySingletons()方法的时候，bean不会马上销毁，但是容器在销毁bean之前，会等到方法结束剩余的任务后
再调用相应的销毁bean之前指定的其他方法。再干掉bean
在 spring 2.5中 ((AbstractApplicationContext)beanFactory).registerShutdownHook();来看看bean的销毁
原型 bean 在创建后即脱离 BeanFactory 的维护，所以只能调用初始化方法，而不能做清理工作。
如果不是Singleton的Bean不能触发结束初始化事件和预销毁事件么？那是因为如果不是单例模式的Bean，Spring不会自己去管理，而是把它们交给Spring框架下的应用本身去管理，这样就相当于把Bean交给了GC。但是如果是单例模式的Bean，Spring会建立一个Bean的列表来统一管理，在Spring应用被关闭的时候，会执行BeanFactory中的destroySingltons()方法来逐个销毁列表中的Bean。这就是为什么只有单例模式实现Spring的那两个事件接口或指定方法属性才是有效的
可以考虑引入bean的后处理技术
9 spring 中bean的作用域（5种）:2.0以前只有单例和非单例 2。0以后有以下5种
singleton
在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype
一个bean定义对应多个对象实例。
request
在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依
据某个bean定义创建而成。该作用 域仅在基于web的Spring ApplicationContext情形下有效。
session
在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring
ApplicationContext情形下有效。
global session
在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet
context的时候有效。该作用域仅在基于 web的Spring ApplicationContext情形下有效。
10 spring在web环境中的配置（2种）
1.在Web.xml中配置上下文载入器
根据你的系统情况,你可以选择两种上下文载入器:ContextLoaderListener和ContextLoaderServlet.
如果你的Web容器支持Servlet2.3标准或更高,你可以使用两者,否则只能使用后者.
（1）ContextLoaderListener在Web.xml应该如下配置:
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
（2）ContextLoaderServlet在Web.xml应该如下配置:
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
2.指定上下文载入器的配置文件
不论你使用的那种上下文载入器,你都应该指明Spring配置文件的位置.如果没有指定,上下文载入器将把/web-inf/applicationContext.xml当作Spring配置文件。
要指定Spring配置文件的位置，你可以在Servlet上下文设置contextConfigLocation参数来为上下文载入器指定一个或多个Spring配置文件
（使用通配符或是用逗号隔开）。如下所示：
<context-param>
<param-name>
contextConfigLocation
</param-name>
<param-value>
/WEB-INF/bean.xml
</param-value>
</context-param>
3.获得应用上下文
接下来我们就可以获得ApplicationContext了，代码如下：
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
在一个自启动的Servlet中，我们可以这样获得它：
public class InitialSystemServlet extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
// 取得Spring的上下文
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());
}
测试web应用环境相关的Bean作用域
spring 2.5 dtd配置
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="test" class="com.Test" >
</bean>
</beans>
如果用户使用spring的webApplicationContext,则可以使用另外3种Bean的作用域:request,session和globalSession.不过
在使用这些作用域之前,首先必须在web容器中进行一些额外的配置,在高版本的web容器中,则可以利用HTTP请求监听器进行配置:
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
细心的同学可能有一个疑问:在介绍webApplicationContext初始化时,我们已经通过ContextLoaderListener将web容器与
spring容器整合,为什么这里又要引入一个额外的RequestContextListener以支持Bean的另外3个作用域呢?
在整合spring容器时使用ContextLoaderListener,它实现了ServletContextListener监听器接口,ServletContextListener
只负责监听web容器启动和关闭的事件.而RequestContextListener实现ServletRequestListener监听器接口,该监听器监听
HTTP请求事件,web服务器接收的每一次请求都会通知该监听器.
spring容器启动和关闭操作由web容器的启动和关闭事件触发,但如果spring容器中的Bean需要request,session,globalsession
作用域的支持,spring容器本身就必须获得web容器的HTTP请求事件,以HTTP请求的事件"驱动"Bean作用域的控制逻辑.
11 spring 对dao的支持
<1>dao模式优点
减少开发代码量 提高工作效率
降低系统资源消耗 提高系统性能
业务逻辑层与持久层(数据层)的分离，使数据与操作更为清晰。
数据访问独立到了一层，修改具体实现类，不影响系统的架构运行
<2>DAO模式的四个组件
DAO接口
DAO接口实现类
pojo值对象
DAO实例的定位(工厂 或 spring注入)
2. 核心类
JdbcTemplate（需要注入DataSource）
JdbcDaoSupport类（简化注入，有一个字段dataSource）
并提供了getJdbcTemplate()方法获得JdbcTemplate实例
DataSource接口
为了从数据库中取得数据，我们首先需要获取一个数据库连接。Spring通过DataSource对象来完成这个工作。
DataSource是JDBC规范的一部分，它被视为一个通用的数据库连接工厂。通过使用DataSource，
Container或Framework可以将连接池以及事务管理的细节从应用代码中分离出来。
作为一个开发人员，在开发和测试产品的过程中，你可能需要知道连接数据库的细节。
但在产品实施时，你不需要知道这些细节。通常数据库管理员会帮你设置好数据源。
在使用Spring JDBC时，你既可以通过JNDI获得数据源，也可以自行配置数据源（使用Spring提供的DataSource实现类）。
使用后者可以更方便的脱离Web容器来进行单元测试。 这里我们将使用DriverManagerDataSource
，不过DataSource有多种实现， 后面我们会讲到。使用DriverManagerDataSource和你以前获取一个JDBC连接 的做法没什么两样。
你首先必须指定JDBC驱动程序的全限定名，这样DriverManager 才能加载JDBC驱动类，接着你必须提供一个url（因JDBC驱动而异，
为了保证设置正确请参考相关JDBC驱动的文档）， 最后你必须提供一个用户连接数据库的用户名和密码。
目前已经有开源的免费用了
DataSource
/ \
/ \
DriverManagerDataSource org.apache.commons.dbcp.BasicDataSource
下面我们将通过一个例子来说明如何配置一个 DataSource ，
1 自己实现DataSource接口，设置数据库相关连接信息
2 使用现有的实现类dataSource 编程方式 获得dataSourc 如下
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver<");
dataSource.setUrl("jdbc:mysql://localhost:3306/j2ee");
dataSource.setUsername("root");
dataSource.setPassword("123456");
3 通过开源dbcp获得dataSource ，spring方式
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/j2ee</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123456</value>
</property>
</bean>
使用Spring的Dao支持来写Dao层，继承JdbcDaoSupport类，JdbcDaoSupport类中有一个字段dataSource
也就是数据库连接，因此只需继承JdbcDaoSupport类，并给它注入dataSource，就隐式的获得了数据库连接，可以在bean.xml文件中
注入connection（即：dataSource）
<beans>
<!-- spring 方式获得dataSource-->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/j2ee</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123456</value>
</property>
</bean>
<bean id="xxx" class="包名.类名(dao的实现类)">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
</beans>
3.在这个Dao 实现类中写一个内部类，使其实现：RowMapper接口，用来封装成具体的pojo对象，代码如下
private class PersonRowMapper implements RowMapper
{
public Object mapRow(ResultSet resultSet, int rowNumber)
throws SQLException {
User user = new User();
user.setId(resultSet.getLong("id"));
user.setName(resultSet.getString("name"));
user.setSex(resultSet.getString("sex"));
user.setAge(resultSet.getInt("age"));
user.setAddr(resultSet.getString("addr"));
return user;
}
}
4 通过JdbcTemplate类进行增删查询修改操作
（1）增加 修改 删除示例
public void createPerson(PersonBean p)
{
Object[] args = {p.getName() , new Integer(p.getAge()) };
getJdbcTemplate().update("insert into person_test(p_name,p_age) values(?,?)", args );
}
（2）查询 返回单个object
public PersonBean getPerson(int id)
{
Object[] args = {new Integer(id)};
//PersonRowMapper是刚刚的内部类
return (PersonBean)getJdbcTemplate().queryForObject("select p_name,p_age from person_test where p_id = ?", args, new PersonRowMapper());
}
(3)返回list
public List findPersonsByName(String name)
{
//PersonRowMapper是刚刚的内部类
return getJdbcTemplate().query("select * from person_test where p_name like '%" + name +"%'" , new PersonRowMapper());
}
5 spring 2.5以后提供了一个SimpleJdbcTemplate类来操作
2.5例子
public class PersonDaoSpring25 implements PersonDao {
private SimpleJdbcTemplate simpleJdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
}
@Override
public void add(Person p) {
// TODO Auto-generated method stub
String sql = "insert into person(name) values(?)";
simpleJdbcTemplate.update(sql, p.getName());
}
@Override
public void del(String id) {
// TODO Auto-generated method stub
String sql="delete from person where id=?";
simpleJdbcTemplate.update(sql, id);
}
@Override
public List findAll() {
// TODO Auto-generated method stub
String sql = "select * from person";
List list = simpleJdbcTemplate.getJdbcOperations().query(sql,
new BeanPropertyRowMapper(Person.class));
return list;
}
@Override
public Person findById(String id) {
String sql = "select * from person where id=?";
Person p = simpleJdbcTemplate.queryForObject(sql,
ParameterizedBeanPropertyRowMapper.newInstance(Person.class),
id);
return p;
}
@Override
public void update(Person p) {
String sql = "update person set name=? where s_id=?";
simpleJdbcTemplate.update(sql, p.getName(), p.getId());
}
}
12 spring aop
AOP的好处:
消除了编码模块之间的依赖
可以在任意阶段，向已有功能模块中填加新功能，且不侵入原有功能
AOP的特征：
各步骤之间的良好隔离性 , 源代码的无关性
Spring 面向方面编程（AOP） spring支持AOP功能，AspectJ更完美的支持AOP
AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中, 将系统中通用的需求功能隔离出来形成一个功能模块，
并将这个模块切入到应用程序当中, AOP追求的是调用者与被调用者的解耦，从而消除了OOP引起的代码混乱和分散问题，
增强了系统的可维护性和代码的重用性
方面：哪方面 系统中分为业务方面的和非业务方面 Spring主要集中于非业务方面 如（日志、事务、安全、权限等）
1.面向方面与面向切面：AOP的实现中的几个重要的概念：
1.1如果理解为“面向方面编程”：
针对于某一模块进行专门的编写(如：面向日志编程，面向事务编程,面向权限等)，其意思就是说面向具体的某个功能模块来编程，然后将其切入到项目中
1.2如果理解为“面向切面编程”：
连接点：程序执行过程中明确的点，如方法的调用或者异常的抛出，举个例子，如果是一个权限系统的话，要控制到类中的某一个具体的方法，那么这个方法就是一个连接点
切入点：连接点的集合，如类中多个个方法的调用， 还是以权限系统来举例，如果要控制一个类中的多个方法的话，那么这几个方法（也即是几个连接点）组成了一个切入点
切面：如果要控制多个类中的多个方法，那么这多个类就组成了一个切面
连接点 --- 切入点 ---- 切面（三者之间的关系可以形象的理解为：点--线--面）
2.1.连接点 --- 切入点 ---- 切面 --- 方面（解决方案的切入点）
2.2.目标对象（也就是：寻找被处理的类）
2.3.AOP代理（具体实现），分为二种，
JDK动态代理（面向接口）
Cglib代理（面向具体类）
2.4.处理（Spring AOP处理）或者叫通知，aop框架在特定的连接点执行的动作，Spring提供了五种处理方式
2.5 Advisor=(处理+切入点)
2.6 下面介绍Spring的处理
实现步骤
（1）目标对象定义 bean定义
(2) 处理与Advisor
<1> 处理 定义（1 在哪里处理<连接点 --- 切入点 ---- 切面 --- 方面> 2什么方式处理<如前处理，后处理，前后都处理>）
如果只是简单的定义处理，则默认的切入点是目标类的所有方法都处理
<2> 如果希望更精确的切入点，则可以采用Advisor（切入点+处理），以下是采用正则表达式支持类RegexpMethodPointcutAdvisor的示例
配置Advisor （Advisor=切入点+通知)
<bean id="testAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- advice属性确定处理bean-->
<property name="advice">
<!-- 此处的处理bean定义采用嵌套bean,也可引用容器的另一个bean-->
<bean class="包名.通知bean类名" />
</property>
<!-- patterns确定正则表达式模式-->
<property name="patterns">
<list>
<!-- 确定正则表达式列表-->
<value>.*say.*</value> <!-- 业务实现方法名匹配 -->
</list>
</property>
</bean>
(3) aop代理对象定义 bean 定义
<0>手写aop代理（编程式）
<1>采用ProxyFactoryBean生成代理
特点：一种接口或者一个类 都需要对应的一个具体代理，需要指定接口或者类 以及对应的代理定义
<bean id="person" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--当用面向具体类实现时 proxyInterfaces属性可以不用注入 此时采用Cglib代理，必须加入Cglib的jar包 -->
<property name="proxyInterfaces">
<value>包名.目标对象的接口</value>
</property>
<property name="target">
<ref local="目标对象的bean id"/>
</property>
<property name="interceptorNames">
<list>
<value>处理bean id</value><!-- list说明可以注入多个处理 -->
</list>
</property>
</bean>
<2> 自动代理 主要采用了 bean的后处理技术 实现了bean的后处理接口BeanPostProcessor,通常有两个常用的实现类
在spring bean 的生命周期中，可以在bean创建之后（如指定init-method），销毁之前(指定distory-method),让容器
执行特定的方法，如果有更多的方法，需要在创建之时（注意是创建之时）被调用，可采用实现BeanPostProcessor接口
使用BeanPostProcessor，让我们的bean实现BeanPostProcessor接口
1 public class Chinese implements Person,BeanPostProcessor{
@Override
public void sayHello() {
// TODO Auto-generated method stub
System.out.println("你好");
}
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1)
throws BeansException {
// TODO Auto-generated method stub
System.out.println("进入postProcessAfterInitialization方法");
System.out.println(arg1);//返回之前可以包装一下
return arg0;
}
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1)
throws BeansException {
// TODO Auto-generated method stub
System.out.println("进入postProcessBeforeInitialization方法");
System.out.println(arg1);//返回之前可以包装一下
return arg0;
}
}
2 客户端调用
Resource res = new FileSystemResource("src/beans.xml");
XmlBeanFactory beanFactory = new XmlBeanFactory(res);
Chinese c = new Chinese();
beanFactory.addBeanPostProcessor(c);//注意这句哦，注册BeanPostProcessor
Person p = (Person)beanFactory.getBean("chinese");
spring为我们提供了以下两种实现
BeanPostProcessor
/ \
/ \
BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator
<2.1> 采用BeanNameAutoProxyCreator自动生成代理
特点：多种接口或者多个类 自动创建其对应代理，需要指定接口或者类。接口或者类共用一个自动代理
<!-- 定义BeanNameAutoProxyCreator-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定对满足哪些bean name的bean自动生成业务代理 -->
<property name="beanNames">
<!-- 下面是所有需要自动创建代理的bean-->
<list>
<value>bean id 1</value>
<value>bean id 2</value>
</list>
</property>
<!-- 下面定义BeanNameAutoProxyCreator所需的处理-->
<property name="interceptorNames">
<list>
<value>处理 bean 1</value>
<value>处理 bean 2</value>
</list>
</property>
</bean>
<2.2> 更牛的自动代理DefaultAdvisorAutoProxyCreator，
特点：多种接口或者多个类 自动创建其对应代理，不需要指定接口或者类，提供Advisor(切入点+通知)，默认搜索所有的Advisor 如前面的正则表达式
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
(1).before advice(前置通知) implements MethodBeforeAdvice 重写before()方法
是在目标bean方法调用前调用，没有返回值，通常意外情况下,会继续运行下一步方法.记住的一点是没有返回
例子如下
public class MyBeforeAdvisor implements MethodBeforeAdvice
{
public void before(Method m, Object[] args, Object target) throws Throwable
{
System.out.println("方法调用之前...");
System.out.println("下面是方法调用的信息：");
System.out.println("所执行的方法是:" + m);
System.out.println("调用方法的参数是：" + args);
System.out.println("目标对象是：" + target);
System.out.println("方法调用之前111...");
}
}
(2).after advice(后置通知) implements AfterReturningAdvice 重写afterReturning()方法
是在方法调用后调用，有返回值，记住的一点是有返回值。
public void afterReturning(Object returnValue, Method m, Object[] args, Object target)throws Throwable
{
System.out.println("方法调用结束...");
System.out.println("目标方法的返回值是 : " + returnValue);
System.out.println("目标方法是 : " + m);
System.out.println("目标方法的参数是 : " + args);
System.out.println("目标对象是 : " + target);
}
(3).around advice(环绕通知) implements MethodInterceptor 重写其内的invoke()方法，实现方式与Struts2的拦截器一模一样
调用其 MethodInvocation 的proceed()方法;
例子如下
public class MyAroundInterceptor implements MethodInterceptor
{
public Object invoke(MethodInvocation invocation) throws Throwable
{
System.out.println("调用生小孩方法之前娶老婆: invocation对象：[" + invocation + "]");
Object rval = invocation.proceed();
System.out.println("调用方法之后...坐月子");
return rval;
}
}
(4).throws advice(异常通知) implements ThrowsAdvice
例子如下
public class MyExceptionAdvice implements ThrowsAdvice
{
public void afterThrowing(ClassNotFoundException ex) throws Throwable
{
System.out.println("系统抛出ClassNotFoundException异常，异常提示为： " + ex.getMessage());
}
public void afterThrowing(Method m,Object[] o,Object target,Throwable e)throws Throwable{
System.out.println("消息："+e.getMessage());
}
public void afterThrowing(Method m, Object[] args, Object target, ArithmeticException ex)
{
System.out.println("系统抛出ArithmeticException异常，异常提示为： " + ex.getMessage());
System.out.println("抛出异常的方法为： " + m);
System.out.println("抛出异常的方法的参数为： " + args);
System.out.println("抛出异常的目标对象为： " + target);
}
}
(5).introduce advice(引入通知)
引入通知是一种特殊的通知，它能将新的成员变量、成员方法引入到目标类中。它不能作用于任何切入点，
因为它只作用于类层次，而不是方法层次。实现引入通知需要实现IntroductionAdvisor和IntroductionInterceptor接口。
引入通知不能调用proceed方法。Advisor必须针对每个实例，并且是有状态的。
引入通知的效果类似于设计模式中的访问者模式(Visitor Pattern)
3.AOP实现过程中的几种不同的方式：
3.1：拦截一类中所有的方法（连接点）
3.2：拦截一个类中的某些符合条件的方法（切入点）
3.3：拦截多个类中的符合条件的方法（切面）
4 利用aop进行事务编程 Spring事务配置的五种方式 （掌握Spring事务体系图）
传统上，J2EE开发者有两个事务管理的选择： 全局 或 本地事务（局部事务）。全局事务由应用服务器管理，使用JTA。
局部事务是和资源相关的，比如一个和JDBC连接关联的事务
事务种类分为： jdbc事务（局部事务） jta事务（全局事务） 容器事务
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。局部事务
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。全局事务
3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用
两种事务的比较
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂
从实现的角度划分
Spring把事务分为两种一种是：编程式事务，一种是声明式事务。
编程式事务是侵入式事务 比较灵活，编程式事务则要操作逻辑代码。存在重复的代码比较多，相对繁琐，而且不利于系统的扩展；
声明式事务是非侵入式的事务。声明式事务只需在配置文件中配置，而不需要去操作逻辑代码。
spring事务的7大传播属性
1.PROPAGATION_MANDATORY:要求调用该方法的线程必须处于事务环境中，否则抛出异常。
2.PROPAGATION_NESTED:如果执行该方法的线程已处于事务环境下，依然启动新的事务，方法在嵌套的事务里执行。
如果执行该方法的线程并未处于事务中，也启动新的事务，然后执行该方法，此时与PROPAGATION_REQUIRED相同。
3.PROPAGATION_NEVER:不允许调用该方法的线程处于事务环境下，如果调用该方法的线程处于事务环境下，则抛出异常。
4.PEOPAGATION_NOT_SUPPORTED:如果调用该方法的线程处于在事务中，则先暂停当前事务，然后执行该方法。
5.PEOPAGATION_REQUIRED：要求在事务环境中执行该方法，如果当前执行线程已处于事务中，则直接调用，
如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
6.PEOPAGATION_REQUIRES_NEW:该方法要求有一个在新的事务环境中执行，如果当前执行线程已处于事务中，
先暂停当前事务,启动新的事务后执行该方法；如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
7.PEOPAGATION_SUPPORTS:如果当前执行线程已处于事务中，则使用当前事务，否则不使用事务。
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。根据代理机制的不同，总结了五种Spring事务的配置方式
现在以dataSource为例，当然要先配置dataSource，参见去前面文档spring方式获得dataSource部分
<1> 每个bean有一个代理
<1.1>配置事务管理器transactionManager
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 给DataSourceTransactionManager注入dataSource-->
<property name="dataSource"><ref local="dataSource"/></property>
</bean>
<1.2>配置事务代理bean TransactionProxyFactoryBean
<bean id="xxx"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 配置事务管理器 引用上面配置的来注入 -->
<property name="transactionManager" ref="transactionManager" />
<property name="target" ref="操作数据库的目标 dao bean id" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<2> 所有Bean共享一个代理基类 实则上就是spring 的模板机制 配置一个模板，使其为abstract="true"
spring中bean 的继承 在java 类中称为继承 在spring称为模板
<2.1>代理定义 定义模板（父类）
<bean id="baseTxProxy" lazy-init="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager"><ref bean="transactionManager"/></property>
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<2.2> 为不同的dao操作类加上事务
<!-- 给dao1加事务-->
<bean id="daotran1" parent="baseTxProxy"> <!-- baseTxProxy为刚刚配置的模板-->
<property name="target">
<ref local="dao1"/>
</property>
</bean>
<!-- 给dao2加事务-->
<bean id="daotran2" parent="baseTxProxy">
<property name="target">
<ref local="dao2"/>
</property>
</bean>
<3>使用拦截器
<3.1>定义事务拦截器 org.springframework.transaction.interceptor.TransactionInterceptor
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 配置事务管理器 引用上面配置的来注入 -->
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<3.2> 定义代理 bean 采用自动代理 BeanNameAutoProxyCreator （前面讲过有例子）
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*dao</value> <!-- dao bean id匹配 -->
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value> <!-- 引用事务拦截器 -->
</list>
</property>
</bean>
13 spring与struts的整合
整合中要思考的是：怎样才能加载和实例化spring容器.先把spring容器放到web容器中，然后再根据一些方法去提取,
13.1 在Strust1中直接使用spring
让我们回顾一下前面所讲的如何在web环境中使用spring,
根据servlet版本的不用，我们可以通过在web.xml里配置servlet或者监听器来实例化spring容器，
1.在web.xml中配置
①.加载spring 容器
<!-- 加载spring 容器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/beans.xml</param-value>
</context-param>
②.实例化spring 容器
<!-- 初始化spring容器方法一 servlet版本 前面有讲述-->
<servlet>
<servlet-name>contextLoader</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<!-- 初始化spring容器方法二 监听器版 前面有讲述-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
之后就可以通过WebApplicationContextUtils取得Spring的上下文
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(当前ServletContext);
如在struts1中,必须知道当前的servlet上下文
①WebApplicationContext ctx=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
②WebApplicationContext beanFactory=WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
如在struts2中
WebApplicationContext ctx=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
有了WebApplicationContext实例，我们就可以通过getBean方法获得spring容器中的bean了,如下所示
13.2 Strust1整合Spring的其他3种方式
在上面的Strust1中直接使用Spring，我们是通过在web.xml中配置servlet或者是listener加载和实例化spring容器。实则上
spring提供了一种专门针对于struts的插件来加载和实例化spring容器，只需在struts-config.xml加入即可，
所以我们如果不想用前面的来加载可以使用下面的
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>
<!--
注意 /WEB-INF/classes/applicationContext.xml这个位置，如果你的文件在WEB-INF。则写成/WEB-INF/applicationContext.xml
在eclipse 中 /WEB-INF/classes/applicationContext.xml对应的目录是src目录,applicationContext.xml放在src下
-->
◆使用Spring的ActionSupport类整合Structs
优点：
1) 简单
缺点：
1) 耦合高 它将Struts动作与Spring框架耦合在一起。如果您想替换掉Spring，那么您必须重写代码
2) 违反IOC
3) 无法使用 DispatchAction
◆使用Spring的DelegatingRequestProcessor覆盖Struts的RequestProcessor
DelegatingRequestProcessor方法的确比第一种方法好，缺点 RequestProcessor如果改变了怎么办或者是有不同的RequestProcessor怎么办呢
◆将Struts Action管理委托给Spring框架
动作委托解决方法是这三种方法中最好的。Struts动作不了解Spring，不对代码作任何改变就可用于非Spring应用程序中。RequestProcessor的改变不会影响它，并且它可以利用Spring AOP特性的优点。
优点
1. 动作委托解决方法是这三种方法中最好的。
2. 不使用Spring api编写 Action
3. 利用了IOC装配
三种方式的相关配置：
<1> Action直接继承ActionSupport，在Action类的execute()方法中通过
ApplicationContext ctx=getWebApplicationContext()获得Spring的
上下文，通过上下文获取相应的bean实例
<2>覆盖RequestProcessor
1.在struts-config.xml中配置控制器
<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/>
2.在applicationContext.xml文件中注册action动作bean
<bean name="/struts-config.xml配置的对应action的path" class="Action类的包名类名" >
<!--注意上面的是name而不是大家经常写的id-->
<property name="service">
<ref bean="service" /> <!--注入spring实例，假设属性名为service-->
</property>
</bean>
3.Action类中声明一个Service私有属性及其setter方法，通过IOC注入Service实例。
<3>动作管理委托给Spring
1.struts-config.xml中action标签内的type属性值替换为org.springframework.web.struts.DelegatingActionProxy,如下
<action input="/index.jsp" path="/hello" scope="session"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="success" path="/success.jsp" />
</action>
2.在applicationContext.xml文件中注册action动作bean
<bean name="/struts-config.xml配置的对应action的path" class="Action类的包名.类名" >
<property name="service">
<ref bean="service" />
</property>
</bean>
3.Action类中声明一个Service私有属性及其setter方法，通过IOC注入Service实例
13.2 Spring与Struts2的整合
由于Struts2得强大可插拔式设计，使得整合spring的工作变得异常简单，struts2-spring-plugin-2.0.8.jar就是支持spring的插件包
0.把struts2支持spring的插件包jar拷贝到项目中
1.web.xml的配置：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!-- 监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 定义Struts2的FilterDispathcer的Filter -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<!-- FilterDispatcher用来初始化struts2并且处理所有的WEB请求。 -->
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2.applicationContext.xml的配置(WEB-INF目录下)
(如果不使用默认的 则可以在web.xml通过以下配置修改xml的配置以及名称)
<!-- 加载spring 容器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/beans.xml</param-value>
</context-param>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean name="service" class="com.service.impl.ServiceImpl"/>
<!-- action的配置 -->
<bean name="abc" class="com.LoginAction" >
<property name="service">
<ref bean="service" /> <!--注入spring实例，假设action类中有一个属性名为service-->
</property>
</bean>
</beans>
3.struts.xml的配置
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-default.xml" />
<package name="default" extends="struts-default">
<!-- action标签中的class属性与applicationContext.xml中的action的bean的name属性一致 如以下的abc -->
<action name="login" class="abc">
<result name="input" >/login.jsp</result>
<result name="success">/welcome.jsp</result>
<result name="error">/failed.jsp</result>
</action>
</package>
</struts>
4.action类中声明service的一个变量及setter方法
14 Spring2.5有哪些改进
Spring2.5rc1发布了，一直想知道它葫芦里卖什么药
1 spring bean的作用域 已经有原来的单例和非单例 变成了5个
2 Jar 包：一个包分解成多个包 如 SpringMVC 不再使用spring.jar 这个庞大的包了。 Spring-webmvc.jar, spring-webmvc-portlet.jar 可以在 lib/modules 目录下找到，而且对于Struts1.* 的支持的包也应该改成 spring-webmvc-struts.jar了。
3 Hibernate：注意Spring已经不再支持Hibernate 3.1之前的版本了，也就是说2.1，3.0的版本也无法使用了。如果仍然要用的话，推荐使用Spring的2.0.6/2.0.7版本。
4． JDK版本： JDK至少要1.4.2以上，如果仍然打算使用1.3的话就请用2.0.6/2.0.7版本吧。
5． XML配置：推荐使用XML metadata格式，不过先前的DTD仍然支持。需要注意的一点是，Spring2.0的DTD继续使用“singleton”属性，但是新的Spring2.5 DTD不允许使用“singleton”属性了，改成“scope”属性来描述bean的生命周期。
6． 废弃的类与方法：有些在先前版本标注过“@deprecated”的类与方法已经完全被废弃了。
比如：
1.
ResultReader : 被 RowMapper 接口取代。
2.
BeanFactoryBootstrap : 考虑使用 BeanFactoryLocator 或自定义的bootstrap类来代替。
7． Apache OJB：注意Spring源代码中已经完全把这个去掉了，但与之整合的类仍然可以在Spring Modules project找到。https://springmodules.dev.java.net/
8． iBATIS：注意Spring已经不再支持iBATIS 的1.3版本了， 如果想继续的话，请升级到2.3以上吧。
9． JDO：注意Spring已经不支持JDO1.0了。同样，你可以升级到2.0以上版本，或者使用Spring的2.0.6/2.0.7版本。
10． UrlFilenameViewController：这个东东我也没有接触过，这里，我就简单翻译一下吧。
“考虑到嵌套路径的请求，视图名称现在决定叫UrlFilenameViewController了，这是一个突破性的改变，并且意味着如果你从Spring1.* 升级到Spring2.0 你可以使用该类从而减少Spring Web MVC的配置工作。”
15 spring 注解
<一> 1 @Autowired 2 @Autowired
@Qualifier("bean名称")
需要<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<二> JSR-250 的注释 @Resource @PostConstruct 和 @PreDestroy
加入common-annotations.jar包
需要<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
可用 <context:annotation-config/>。简化第一和第二的配置 请看下面的配置：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
<bean id="chinese" class="com.Chinese"></bean>
<bean id="American" class="com.American"></bean>
<bean id="test" class="com.Test"></bean>
</beans>
<三> @Component
Component或者@Component("bean名") @Component默认bean名为类名 首字母小写
不需要配置bean 配置文件如下
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com"/> <!--com包 这里改成你的包名-->
</beans>
以下是具体说明 高手可掠过
Spring 通过一个 BeanPostProcessor 对 注解进行解析，所以要让 注解 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。
如下
<!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
15.1 Spring 2.5 引入了 @Autowired 注解，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，按照类型进行装配
如
@Autowired
public void setP(Person p) {
this.p = p;
}
15.2 当不存在不匹配的bean或者是匹配的bean的数目大于1时，按照类型进行装配都会报出异常，可采用以下方式不报都会报出异常
@Autowired(required = false)
15.3 采用以下方式指定bean，按名字匹配
@Autowired
@Qualifier("bean名称")
用在构造方法上
@Autowired
public Test(@Qualifier("chinese")Person p) {
// TODO Auto-generated constructor stub
this.p=p;
}
15.3 使用 JSR-250 的注释 @Resource @PostConstruct 和 @PreDestroy
Spring 不但支持自己定义的 @Autowired 的注释，还支持几个由 JSR-250 规范定义的注释，它们分别是 @Resource、@PostConstruct 以及 @PreDestroy。
为了让 JSR-250 的注释生效，除了在 Bean 类中标注这些注释外，还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor：
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
@Resource
@Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，面 @Resource 默认按 byName 自动注入罢了。@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。
Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中，因此在使用之前必须将其加入到项目的类库中。
JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类，分别是 @PostConstruct 和 @PreDestroy，这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。
使用 <context:annotation-config/> 简化配置
而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是
<context:annotation-config/>。请看下面的配置：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
<bean id="chinese" class="com.Chinese"></bean>
<bean id="American" class="com.American"></bean>
<bean id="test" class="com.Test"></bean>
</beans>
<context:annotationconfig/> 将隐式地向 Spring 容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 以及 equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。
15.4 使用 @Component或者@Component("bean名") @Component默认bean名为类名 首字母小写
然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说，在 XML 配置文件中定义 Bean，通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？答案是肯定的，我们通过 Spring 2.5 提供的 @Component 注释就可以达到这个目标了。
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com"/><!--com包-->
</beans>
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.
spring的设计思想是，单例模式和工厂模式
2 spring的四大特点（优点）
轻量级,低侵入的设计
Spring的DI机制降低了业务对象替换的复杂性
spring不依赖于web容器，独立于各种应用服务器， Write Once,Run Anywhere（一次编译到处运行）
高度开放性：Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部，它的架构仍然是内在稳定的
3 spring的组成部分 七大模块
Spring Core：Spring的基石，提供了Spring的最主要的核心机制：控制反转和依赖注入
Spring Context：提供了Spring的上下文信息，如：国际化，验证等
Spring Web支持：简化了处理多部分请求
Spring MVC框架支持：一个全功能的构建 Web 应用程序的 MVC 实现，MVC 容纳了大量视图技术，其中包括 JSP、Velocity等。
Spring Dao支持：Spring的Dao支持大大的简化了JDBC操作数据库所带来的繁琐
Spring ORM支持 pring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。
所有这些都遵从Spring的通用事务和DAO异常层结构。
Spring AOP：面向方面编程，提供了事务，日志，权限，安全等处理机制
具体解释
Spring 核心容器(Core):提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它
是工厂模式的实现。BeanFactory使用控制反转(Ioc)模式将应用程序的配置和依赖性规范与实际的应
用代码程序分开。
Spring AOP:通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序
中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理
集成到应用程序中。
Spring ORM:Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。
Spring DAO:JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量(例如，打开和关系连接)。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。
Spring WEB:Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用
程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求
及将请求参数绑定到域对象的工作
Spring上下文(Context):Spring上下文是一个配置文件，向Spring框架提供上下文信息。
Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。
Spring MVC:Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，
MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol
4 spring的核心机制
1）.控制反转（IoC/Inverse Of Control）:调用者不再创建被调用者的实例，由spring框架实现（容器创建）所以称为控制反转。
2）.依赖注入(DI/Dependence injection) :创建好实例后再注入调用者称为依赖注入。
当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，
在传统的程序设计过程中，通常由调用者来创建被调用者的实例, 但在Spring里，创建被调用者的工
作不再由调用者来完成，因此称为控制反转; 创建被调用者 实例的工作通常由Spring容器来完成，
然后注入调用者，因此也称为依赖注入
什么是ioc容器
bean工厂(BeanFactory) 和 应用上下文(Application Context)
在Spring中，BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
BeanFactory
|
|
ApplicationContext(国际化)
/ \
/ \
FileSystemXmlApplicationContext ClassPathXmlApplicationContext
常用有三种方式可以得到BeanFactory ，从而bean实例，并进行调用
// InputStream is = new FileInputStream("beans.xml");
// InputStreamResource isr = new InputStreamResource(is);
// BeanFactory beanFactory = new XmlBeanFactory(isr);
//
// Spring给出一些BeanFactory的实现类，其中最为常用的是XmlBeanFactory。
// 1、通过文件系统
// Resource res = new FileSystemResource("src/beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
// 2、通过类路径（class路径 ./表示上级目录）
// ClassPathResource res = new ClassPathResource("./beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
// 3、通过ApplicationContext加载（ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext）
// ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
// new String[] {"./beans.xml"});
// BeanFactory beanFactory = (BeanFactory) appContext;
//
// ClassPathResource res = new ClassPathResource("./beans.xml");
// XmlBeanFactory beanFactory = new XmlBeanFactory(res);
或者 ApplicationContext ctx=new FileSystemXmlApplicationContext("src/bean.xml");
ApplicationContext增加功能 1国际化2事件支持
国际化测试
(1)bean配置
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>message</value>
<!-- 如果有多个资源文件，全部列在此处-->
</list>
</property>
</bean>
（2）
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
String[] a = {"读者"};
String hello = ctx.getMessage("hello",a,Locale.ENGLISH);//英文
Object[] b = {new Date()};
String now = ctx.getMessage("hello",b,Locale.getDefault());//默认
System.out.println(hello);
System.out.println(now);
5 简单测试BeanFactory
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="aaa" class="包名.类名"/>
</beans>
测试 FileSystemXmlApplicationContext默认从项目目录寻找bean配置文件xml
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/bean.xml");
Test t=(Test)ctx.getBean("aaa");
System.out.println(t.getName());
依赖注入的优点，代码将更加清晰，Spring管理bean的灵巧性, bean与bean之间的依赖关系放在配置文件里组织，
不再担心对象之间的依赖关系之后，实现更高层次的松耦合将易如反掌
依赖注入的方式 （为什么叫依赖注入 类的四种关系 ）
(1)set注入(2)构造注入(3)lookup方法注入
setter注入实例
<bean id="aaa" class="包名.类名">
<property name="属性名">
<ref local="另一个bean id"/>//local与bean的区别
</property>
</bean>
//local与bean的区别 local：当前xml bean：整个spring容器
构造注入实例 提供构造方法（注入的实例参数） 要提供无参的构造方法
<bean id="aaa" class="包名.类名">
<constructor-arg><ref bean="steelAxe"/></constructor-arg>
</bean>
(3)lookup方法注入(依赖注入的bean每次都创建一个新实例)
这种方法主要是用在Singleton的Object中使用非Singleton的Bean时，
通过lookup-method的那个方法来取得非Singleton的Bean。一般用的不多，在用这种定义之前最佳想明白你的需求。
1 Singleton的Object 中提供一个抽象方法，返回非Singleton的Bean，此时Singleton的类变成抽象类 如
public abstract class Test//Singleton的Bean {
TestBean tb;//非Singleton的Bean时
public TestBean getTb() {
return tb;
}
public void setTb(TestBean tb) {
this.tb = tb;
}
public abstract TestBean createXxx();
}
2 配置xml
<bean id="testbean" class="com.TestBean" singleton="false"/>//注意singleton="false"
<bean id="test" class="com.Test">
<property name="tb"> <ref local="testbean"/></property>//注意这个依然不能少
<lookup-method name="createXxx" bean="testbean"/>
</bean>
3 测试
Test t=(Test)ctx.getBean("test");
System.out.println("不使用lookup-method注入");
TestBean tb1=t.getTb();
TestBean tb2=t.getTb();
System.out.println(tb1==tb2);
System.out.println("使用lookup-method注入");
TestBean tb3=t.createXxx();
TestBean tb4=t.createXxx();
System.out.println(tb3==tb4);
结果
不使用lookup-method注入
true
使用lookup-method注入
false
注入其他属性例子
<beans>
<bean id="aaa" class="包名.类名"/>
<bean id="bbb" class="lee.Chinese">
<property name="schools">
<list>
<value>小学</value>
<value>中学</value>
<value>大学</value>
</list>
</property>
<property name="score">
<map>
<entry key="数学">
<value>87</value>
</entry>
<entry key="英语">
<value>89</value>
</entry>
<entry key="语文">
<value>82</value>
</entry>
</map>
</property>
<property name="health">
<props>
<prop key="血压">正常</prop>
<prop key="身高">175</prop>
</props>
</property>
<property name="axes">
<set>
<value>xxx</value>
<bean class="包名.类名"/>
<ref local="另外一个bean id"/>
</set>
</property>
</bean>
</beans>
上述中的health指的是Properties属性类
private Properties health = new Properties();
测试 Spring的DI机制降低了业务对象替换的复杂性 面向接口编程的好处 灵活配置
6 spring bean的实例 创建的几种方式
（1）构造器 单例思想
（2）静态工厂（静态方法创建）
静态方法名(iint type)
<bean id="xxx" class="包名.类名（工厂类)" factory-method="静态方法名">
<constructor-arg value="1"></constructor-arg>
</bean>
创建同一接口下不同实例
（3）工厂方法（非静态方法创建）
<bean id="aaa" class="com.PersonFactory(工厂类)">
<property name="type"><value>1</value></property>
</bean>
<bean id="xxx" factory-bean="工厂bean id" factory-method="非静态方法名">
7 自动装配
有两个bean A与B
B作为A的一个属性，当我们没有通过setter注入或者构造注入B实例时，我们可以在A bean中指定autowire属性，
让它在spring容器个根据不同方式自动寻找b实例
自动装配的优缺点：
优点：自动装配能显著减少配置的数量，自动装配可以使配置与java代码同步更新
缺点：Spring会尽量避免在装配不明确的时候进行猜测，容器中可能存在多个bean定义跟自动装配的
setter方法和构造器参数类型匹配
byName（用于set注入） 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如，在bean定义中将autowire设置为by name，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定义，并用它来装配给master属性。
byType 如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通过设置dependency-check="objects"让Spring抛出异常。
constructor 与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
autodetect 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
在用byType时候，如果没有匹配的bean 可测试dependency-check="objects"让Spring抛出异常
8 spring框架中bean的生命周期?
(1) bean定义
在配置文件里面用<bean></bean>来进行定义。
(2) bean初始化
有两种方式初始化: 也可同时使用。参数指定的后执行
A.在配置文件中通过指定init-method属性来完成
B.实现org.springframwork.beans.factory.InitializingBean接口 实现afterPropertiesSet()方法
(3) bean调用
有三种方式可以得到bean实例，并进行调用
(4) bean销毁
销毁有两种方式。也可同时使用参数指定的销毁方法后运行
A.使用配置文件指定的destroy-method属性
B.实现org.springframwork.bean.factory.DisposableBean接口 实现destroy()方法
可以通过调用ConfigurableListableBeanFactory(XmlBeanFactory)里的destroySingletons销毁单例对象，测试destroy()方
ConfigurableListableBeanFactory beanFactory =
new XmlBeanFactory(new FileSystemResource("src/bean.xml"));
beanFactory.destroySingletons();
}
是的， 当调用beanFactory.destroySingletons()方法的时候，bean不会马上销毁，但是容器在销毁bean之前，会等到方法结束剩余的任务后
再调用相应的销毁bean之前指定的其他方法。再干掉bean
在 spring 2.5中 ((AbstractApplicationContext)beanFactory).registerShutdownHook();来看看bean的销毁
原型 bean 在创建后即脱离 BeanFactory 的维护，所以只能调用初始化方法，而不能做清理工作。
如果不是Singleton的Bean不能触发结束初始化事件和预销毁事件么？那是因为如果不是单例模式的Bean，Spring不会自己去管理，而是把它们交给Spring框架下的应用本身去管理，这样就相当于把Bean交给了GC。但是如果是单例模式的Bean，Spring会建立一个Bean的列表来统一管理，在Spring应用被关闭的时候，会执行BeanFactory中的destroySingltons()方法来逐个销毁列表中的Bean。这就是为什么只有单例模式实现Spring的那两个事件接口或指定方法属性才是有效的
可以考虑引入bean的后处理技术
9 spring 中bean的作用域（5种）:2.0以前只有单例和非单例 2。0以后有以下5种
singleton
在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype
一个bean定义对应多个对象实例。
request
在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依
据某个bean定义创建而成。该作用 域仅在基于web的Spring ApplicationContext情形下有效。
session
在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring
ApplicationContext情形下有效。
global session
在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet
context的时候有效。该作用域仅在基于 web的Spring ApplicationContext情形下有效。
10 spring在web环境中的配置（2种）
1.在Web.xml中配置上下文载入器
根据你的系统情况,你可以选择两种上下文载入器:ContextLoaderListener和ContextLoaderServlet.
如果你的Web容器支持Servlet2.3标准或更高,你可以使用两者,否则只能使用后者.
（1）ContextLoaderListener在Web.xml应该如下配置:
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
（2）ContextLoaderServlet在Web.xml应该如下配置:
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
2.指定上下文载入器的配置文件
不论你使用的那种上下文载入器,你都应该指明Spring配置文件的位置.如果没有指定,上下文载入器将把/web-inf/applicationContext.xml当作Spring配置文件。
要指定Spring配置文件的位置，你可以在Servlet上下文设置contextConfigLocation参数来为上下文载入器指定一个或多个Spring配置文件
（使用通配符或是用逗号隔开）。如下所示：
<context-param>
<param-name>
contextConfigLocation
</param-name>
<param-value>
/WEB-INF/bean.xml
</param-value>
</context-param>
3.获得应用上下文
接下来我们就可以获得ApplicationContext了，代码如下：
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
在一个自启动的Servlet中，我们可以这样获得它：
public class InitialSystemServlet extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
// 取得Spring的上下文
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());
}
测试web应用环境相关的Bean作用域
spring 2.5 dtd配置
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="test" class="com.Test" >
</bean>
</beans>
如果用户使用spring的webApplicationContext,则可以使用另外3种Bean的作用域:request,session和globalSession.不过
在使用这些作用域之前,首先必须在web容器中进行一些额外的配置,在高版本的web容器中,则可以利用HTTP请求监听器进行配置:
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
细心的同学可能有一个疑问:在介绍webApplicationContext初始化时,我们已经通过ContextLoaderListener将web容器与
spring容器整合,为什么这里又要引入一个额外的RequestContextListener以支持Bean的另外3个作用域呢?
在整合spring容器时使用ContextLoaderListener,它实现了ServletContextListener监听器接口,ServletContextListener
只负责监听web容器启动和关闭的事件.而RequestContextListener实现ServletRequestListener监听器接口,该监听器监听
HTTP请求事件,web服务器接收的每一次请求都会通知该监听器.
spring容器启动和关闭操作由web容器的启动和关闭事件触发,但如果spring容器中的Bean需要request,session,globalsession
作用域的支持,spring容器本身就必须获得web容器的HTTP请求事件,以HTTP请求的事件"驱动"Bean作用域的控制逻辑.
11 spring 对dao的支持
<1>dao模式优点
减少开发代码量 提高工作效率
降低系统资源消耗 提高系统性能
业务逻辑层与持久层(数据层)的分离，使数据与操作更为清晰。
数据访问独立到了一层，修改具体实现类，不影响系统的架构运行
<2>DAO模式的四个组件
DAO接口
DAO接口实现类
pojo值对象
DAO实例的定位(工厂 或 spring注入)
2. 核心类
JdbcTemplate（需要注入DataSource）
JdbcDaoSupport类（简化注入，有一个字段dataSource）
并提供了getJdbcTemplate()方法获得JdbcTemplate实例
DataSource接口
为了从数据库中取得数据，我们首先需要获取一个数据库连接。Spring通过DataSource对象来完成这个工作。
DataSource是JDBC规范的一部分，它被视为一个通用的数据库连接工厂。通过使用DataSource，
Container或Framework可以将连接池以及事务管理的细节从应用代码中分离出来。
作为一个开发人员，在开发和测试产品的过程中，你可能需要知道连接数据库的细节。
但在产品实施时，你不需要知道这些细节。通常数据库管理员会帮你设置好数据源。
在使用Spring JDBC时，你既可以通过JNDI获得数据源，也可以自行配置数据源（使用Spring提供的DataSource实现类）。
使用后者可以更方便的脱离Web容器来进行单元测试。 这里我们将使用DriverManagerDataSource
，不过DataSource有多种实现， 后面我们会讲到。使用DriverManagerDataSource和你以前获取一个JDBC连接 的做法没什么两样。
你首先必须指定JDBC驱动程序的全限定名，这样DriverManager 才能加载JDBC驱动类，接着你必须提供一个url（因JDBC驱动而异，
为了保证设置正确请参考相关JDBC驱动的文档）， 最后你必须提供一个用户连接数据库的用户名和密码。
目前已经有开源的免费用了
DataSource
/ \
/ \
DriverManagerDataSource org.apache.commons.dbcp.BasicDataSource
下面我们将通过一个例子来说明如何配置一个 DataSource ，
1 自己实现DataSource接口，设置数据库相关连接信息
2 使用现有的实现类dataSource 编程方式 获得dataSourc 如下
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver<");
dataSource.setUrl("jdbc:mysql://localhost:3306/j2ee");
dataSource.setUsername("root");
dataSource.setPassword("123456");
3 通过开源dbcp获得dataSource ，spring方式
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/j2ee</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123456</value>
</property>
</bean>
使用Spring的Dao支持来写Dao层，继承JdbcDaoSupport类，JdbcDaoSupport类中有一个字段dataSource
也就是数据库连接，因此只需继承JdbcDaoSupport类，并给它注入dataSource，就隐式的获得了数据库连接，可以在bean.xml文件中
注入connection（即：dataSource）
<beans>
<!-- spring 方式获得dataSource-->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/j2ee</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>123456</value>
</property>
</bean>
<bean id="xxx" class="包名.类名(dao的实现类)">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
</beans>
3.在这个Dao 实现类中写一个内部类，使其实现：RowMapper接口，用来封装成具体的pojo对象，代码如下
private class PersonRowMapper implements RowMapper
{
public Object mapRow(ResultSet resultSet, int rowNumber)
throws SQLException {
User user = new User();
user.setId(resultSet.getLong("id"));
user.setName(resultSet.getString("name"));
user.setSex(resultSet.getString("sex"));
user.setAge(resultSet.getInt("age"));
user.setAddr(resultSet.getString("addr"));
return user;
}
}
4 通过JdbcTemplate类进行增删查询修改操作
（1）增加 修改 删除示例
public void createPerson(PersonBean p)
{
Object[] args = {p.getName() , new Integer(p.getAge()) };
getJdbcTemplate().update("insert into person_test(p_name,p_age) values(?,?)", args );
}
（2）查询 返回单个object
public PersonBean getPerson(int id)
{
Object[] args = {new Integer(id)};
//PersonRowMapper是刚刚的内部类
return (PersonBean)getJdbcTemplate().queryForObject("select p_name,p_age from person_test where p_id = ?", args, new PersonRowMapper());
}
(3)返回list
public List findPersonsByName(String name)
{
//PersonRowMapper是刚刚的内部类
return getJdbcTemplate().query("select * from person_test where p_name like '%" + name +"%'" , new PersonRowMapper());
}
5 spring 2.5以后提供了一个SimpleJdbcTemplate类来操作
2.5例子
public class PersonDaoSpring25 implements PersonDao {
private SimpleJdbcTemplate simpleJdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
}
@Override
public void add(Person p) {
// TODO Auto-generated method stub
String sql = "insert into person(name) values(?)";
simpleJdbcTemplate.update(sql, p.getName());
}
@Override
public void del(String id) {
// TODO Auto-generated method stub
String sql="delete from person where id=?";
simpleJdbcTemplate.update(sql, id);
}
@Override
public List findAll() {
// TODO Auto-generated method stub
String sql = "select * from person";
List list = simpleJdbcTemplate.getJdbcOperations().query(sql,
new BeanPropertyRowMapper(Person.class));
return list;
}
@Override
public Person findById(String id) {
String sql = "select * from person where id=?";
Person p = simpleJdbcTemplate.queryForObject(sql,
ParameterizedBeanPropertyRowMapper.newInstance(Person.class),
id);
return p;
}
@Override
public void update(Person p) {
String sql = "update person set name=? where s_id=?";
simpleJdbcTemplate.update(sql, p.getName(), p.getId());
}
}
12 spring aop
AOP的好处:
消除了编码模块之间的依赖
可以在任意阶段，向已有功能模块中填加新功能，且不侵入原有功能
AOP的特征：
各步骤之间的良好隔离性 , 源代码的无关性
Spring 面向方面编程（AOP） spring支持AOP功能，AspectJ更完美的支持AOP
AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中, 将系统中通用的需求功能隔离出来形成一个功能模块，
并将这个模块切入到应用程序当中, AOP追求的是调用者与被调用者的解耦，从而消除了OOP引起的代码混乱和分散问题，
增强了系统的可维护性和代码的重用性
方面：哪方面 系统中分为业务方面的和非业务方面 Spring主要集中于非业务方面 如（日志、事务、安全、权限等）
1.面向方面与面向切面：AOP的实现中的几个重要的概念：
1.1如果理解为“面向方面编程”：
针对于某一模块进行专门的编写(如：面向日志编程，面向事务编程,面向权限等)，其意思就是说面向具体的某个功能模块来编程，然后将其切入到项目中
1.2如果理解为“面向切面编程”：
连接点：程序执行过程中明确的点，如方法的调用或者异常的抛出，举个例子，如果是一个权限系统的话，要控制到类中的某一个具体的方法，那么这个方法就是一个连接点
切入点：连接点的集合，如类中多个个方法的调用， 还是以权限系统来举例，如果要控制一个类中的多个方法的话，那么这几个方法（也即是几个连接点）组成了一个切入点
切面：如果要控制多个类中的多个方法，那么这多个类就组成了一个切面
连接点 --- 切入点 ---- 切面（三者之间的关系可以形象的理解为：点--线--面）
2.1.连接点 --- 切入点 ---- 切面 --- 方面（解决方案的切入点）
2.2.目标对象（也就是：寻找被处理的类）
2.3.AOP代理（具体实现），分为二种，
JDK动态代理（面向接口）
Cglib代理（面向具体类）
2.4.处理（Spring AOP处理）或者叫通知，aop框架在特定的连接点执行的动作，Spring提供了五种处理方式
2.5 Advisor=(处理+切入点)
2.6 下面介绍Spring的处理
实现步骤
（1）目标对象定义 bean定义
(2) 处理与Advisor
<1> 处理 定义（1 在哪里处理<连接点 --- 切入点 ---- 切面 --- 方面> 2什么方式处理<如前处理，后处理，前后都处理>）
如果只是简单的定义处理，则默认的切入点是目标类的所有方法都处理
<2> 如果希望更精确的切入点，则可以采用Advisor（切入点+处理），以下是采用正则表达式支持类RegexpMethodPointcutAdvisor的示例
配置Advisor （Advisor=切入点+通知)
<bean id="testAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- advice属性确定处理bean-->
<property name="advice">
<!-- 此处的处理bean定义采用嵌套bean,也可引用容器的另一个bean-->
<bean class="包名.通知bean类名" />
</property>
<!-- patterns确定正则表达式模式-->
<property name="patterns">
<list>
<!-- 确定正则表达式列表-->
<value>.*say.*</value> <!-- 业务实现方法名匹配 -->
</list>
</property>
</bean>
(3) aop代理对象定义 bean 定义
<0>手写aop代理（编程式）
<1>采用ProxyFactoryBean生成代理
特点：一种接口或者一个类 都需要对应的一个具体代理，需要指定接口或者类 以及对应的代理定义
<bean id="person" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--当用面向具体类实现时 proxyInterfaces属性可以不用注入 此时采用Cglib代理，必须加入Cglib的jar包 -->
<property name="proxyInterfaces">
<value>包名.目标对象的接口</value>
</property>
<property name="target">
<ref local="目标对象的bean id"/>
</property>
<property name="interceptorNames">
<list>
<value>处理bean id</value><!-- list说明可以注入多个处理 -->
</list>
</property>
</bean>
<2> 自动代理 主要采用了 bean的后处理技术 实现了bean的后处理接口BeanPostProcessor,通常有两个常用的实现类
在spring bean 的生命周期中，可以在bean创建之后（如指定init-method），销毁之前(指定distory-method),让容器
执行特定的方法，如果有更多的方法，需要在创建之时（注意是创建之时）被调用，可采用实现BeanPostProcessor接口
使用BeanPostProcessor，让我们的bean实现BeanPostProcessor接口
1 public class Chinese implements Person,BeanPostProcessor{
@Override
public void sayHello() {
// TODO Auto-generated method stub
System.out.println("你好");
}
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1)
throws BeansException {
// TODO Auto-generated method stub
System.out.println("进入postProcessAfterInitialization方法");
System.out.println(arg1);//返回之前可以包装一下
return arg0;
}
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1)
throws BeansException {
// TODO Auto-generated method stub
System.out.println("进入postProcessBeforeInitialization方法");
System.out.println(arg1);//返回之前可以包装一下
return arg0;
}
}
2 客户端调用
Resource res = new FileSystemResource("src/beans.xml");
XmlBeanFactory beanFactory = new XmlBeanFactory(res);
Chinese c = new Chinese();
beanFactory.addBeanPostProcessor(c);//注意这句哦，注册BeanPostProcessor
Person p = (Person)beanFactory.getBean("chinese");
spring为我们提供了以下两种实现
BeanPostProcessor
/ \
/ \
BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator
<2.1> 采用BeanNameAutoProxyCreator自动生成代理
特点：多种接口或者多个类 自动创建其对应代理，需要指定接口或者类。接口或者类共用一个自动代理
<!-- 定义BeanNameAutoProxyCreator-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定对满足哪些bean name的bean自动生成业务代理 -->
<property name="beanNames">
<!-- 下面是所有需要自动创建代理的bean-->
<list>
<value>bean id 1</value>
<value>bean id 2</value>
</list>
</property>
<!-- 下面定义BeanNameAutoProxyCreator所需的处理-->
<property name="interceptorNames">
<list>
<value>处理 bean 1</value>
<value>处理 bean 2</value>
</list>
</property>
</bean>
<2.2> 更牛的自动代理DefaultAdvisorAutoProxyCreator，
特点：多种接口或者多个类 自动创建其对应代理，不需要指定接口或者类，提供Advisor(切入点+通知)，默认搜索所有的Advisor 如前面的正则表达式
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
(1).before advice(前置通知) implements MethodBeforeAdvice 重写before()方法
是在目标bean方法调用前调用，没有返回值，通常意外情况下,会继续运行下一步方法.记住的一点是没有返回
例子如下
public class MyBeforeAdvisor implements MethodBeforeAdvice
{
public void before(Method m, Object[] args, Object target) throws Throwable
{
System.out.println("方法调用之前...");
System.out.println("下面是方法调用的信息：");
System.out.println("所执行的方法是:" + m);
System.out.println("调用方法的参数是：" + args);
System.out.println("目标对象是：" + target);
System.out.println("方法调用之前111...");
}
}
(2).after advice(后置通知) implements AfterReturningAdvice 重写afterReturning()方法
是在方法调用后调用，有返回值，记住的一点是有返回值。
public void afterReturning(Object returnValue, Method m, Object[] args, Object target)throws Throwable
{
System.out.println("方法调用结束...");
System.out.println("目标方法的返回值是 : " + returnValue);
System.out.println("目标方法是 : " + m);
System.out.println("目标方法的参数是 : " + args);
System.out.println("目标对象是 : " + target);
}
(3).around advice(环绕通知) implements MethodInterceptor 重写其内的invoke()方法，实现方式与Struts2的拦截器一模一样
调用其 MethodInvocation 的proceed()方法;
例子如下
public class MyAroundInterceptor implements MethodInterceptor
{
public Object invoke(MethodInvocation invocation) throws Throwable
{
System.out.println("调用生小孩方法之前娶老婆: invocation对象：[" + invocation + "]");
Object rval = invocation.proceed();
System.out.println("调用方法之后...坐月子");
return rval;
}
}
(4).throws advice(异常通知) implements ThrowsAdvice
例子如下
public class MyExceptionAdvice implements ThrowsAdvice
{
public void afterThrowing(ClassNotFoundException ex) throws Throwable
{
System.out.println("系统抛出ClassNotFoundException异常，异常提示为： " + ex.getMessage());
}
public void afterThrowing(Method m,Object[] o,Object target,Throwable e)throws Throwable{
System.out.println("消息："+e.getMessage());
}
public void afterThrowing(Method m, Object[] args, Object target, ArithmeticException ex)
{
System.out.println("系统抛出ArithmeticException异常，异常提示为： " + ex.getMessage());
System.out.println("抛出异常的方法为： " + m);
System.out.println("抛出异常的方法的参数为： " + args);
System.out.println("抛出异常的目标对象为： " + target);
}
}
(5).introduce advice(引入通知)
引入通知是一种特殊的通知，它能将新的成员变量、成员方法引入到目标类中。它不能作用于任何切入点，
因为它只作用于类层次，而不是方法层次。实现引入通知需要实现IntroductionAdvisor和IntroductionInterceptor接口。
引入通知不能调用proceed方法。Advisor必须针对每个实例，并且是有状态的。
引入通知的效果类似于设计模式中的访问者模式(Visitor Pattern)
3.AOP实现过程中的几种不同的方式：
3.1：拦截一类中所有的方法（连接点）
3.2：拦截一个类中的某些符合条件的方法（切入点）
3.3：拦截多个类中的符合条件的方法（切面）
4 利用aop进行事务编程 Spring事务配置的五种方式 （掌握Spring事务体系图）
传统上，J2EE开发者有两个事务管理的选择： 全局 或 本地事务（局部事务）。全局事务由应用服务器管理，使用JTA。
局部事务是和资源相关的，比如一个和JDBC连接关联的事务
事务种类分为： jdbc事务（局部事务） jta事务（全局事务） 容器事务
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。局部事务
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。全局事务
3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用
两种事务的比较
1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。
2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂
从实现的角度划分
Spring把事务分为两种一种是：编程式事务，一种是声明式事务。
编程式事务是侵入式事务 比较灵活，编程式事务则要操作逻辑代码。存在重复的代码比较多，相对繁琐，而且不利于系统的扩展；
声明式事务是非侵入式的事务。声明式事务只需在配置文件中配置，而不需要去操作逻辑代码。
spring事务的7大传播属性
1.PROPAGATION_MANDATORY:要求调用该方法的线程必须处于事务环境中，否则抛出异常。
2.PROPAGATION_NESTED:如果执行该方法的线程已处于事务环境下，依然启动新的事务，方法在嵌套的事务里执行。
如果执行该方法的线程并未处于事务中，也启动新的事务，然后执行该方法，此时与PROPAGATION_REQUIRED相同。
3.PROPAGATION_NEVER:不允许调用该方法的线程处于事务环境下，如果调用该方法的线程处于事务环境下，则抛出异常。
4.PEOPAGATION_NOT_SUPPORTED:如果调用该方法的线程处于在事务中，则先暂停当前事务，然后执行该方法。
5.PEOPAGATION_REQUIRED：要求在事务环境中执行该方法，如果当前执行线程已处于事务中，则直接调用，
如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
6.PEOPAGATION_REQUIRES_NEW:该方法要求有一个在新的事务环境中执行，如果当前执行线程已处于事务中，
先暂停当前事务,启动新的事务后执行该方法；如果当前执行线程不已处于事务中，则启动新的事务后执行该方法。
7.PEOPAGATION_SUPPORTS:如果当前执行线程已处于事务中，则使用当前事务，否则不使用事务。
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。根据代理机制的不同，总结了五种Spring事务的配置方式
现在以dataSource为例，当然要先配置dataSource，参见去前面文档spring方式获得dataSource部分
<1> 每个bean有一个代理
<1.1>配置事务管理器transactionManager
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 给DataSourceTransactionManager注入dataSource-->
<property name="dataSource"><ref local="dataSource"/></property>
</bean>
<1.2>配置事务代理bean TransactionProxyFactoryBean
<bean id="xxx"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 配置事务管理器 引用上面配置的来注入 -->
<property name="transactionManager" ref="transactionManager" />
<property name="target" ref="操作数据库的目标 dao bean id" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<2> 所有Bean共享一个代理基类 实则上就是spring 的模板机制 配置一个模板，使其为abstract="true"
spring中bean 的继承 在java 类中称为继承 在spring称为模板
<2.1>代理定义 定义模板（父类）
<bean id="baseTxProxy" lazy-init="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager"><ref bean="transactionManager"/></property>
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<2.2> 为不同的dao操作类加上事务
<!-- 给dao1加事务-->
<bean id="daotran1" parent="baseTxProxy"> <!-- baseTxProxy为刚刚配置的模板-->
<property name="target">
<ref local="dao1"/>
</property>
</bean>
<!-- 给dao2加事务-->
<bean id="daotran2" parent="baseTxProxy">
<property name="target">
<ref local="dao2"/>
</property>
</bean>
<3>使用拦截器
<3.1>定义事务拦截器 org.springframework.transaction.interceptor.TransactionInterceptor
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 配置事务管理器 引用上面配置的来注入 -->
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<3.2> 定义代理 bean 采用自动代理 BeanNameAutoProxyCreator （前面讲过有例子）
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*dao</value> <!-- dao bean id匹配 -->
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value> <!-- 引用事务拦截器 -->
</list>
</property>
</bean>
13 spring与struts的整合
整合中要思考的是：怎样才能加载和实例化spring容器.先把spring容器放到web容器中，然后再根据一些方法去提取,
13.1 在Strust1中直接使用spring
让我们回顾一下前面所讲的如何在web环境中使用spring,
根据servlet版本的不用，我们可以通过在web.xml里配置servlet或者监听器来实例化spring容器，
1.在web.xml中配置
①.加载spring 容器
<!-- 加载spring 容器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/beans.xml</param-value>
</context-param>
②.实例化spring 容器
<!-- 初始化spring容器方法一 servlet版本 前面有讲述-->
<servlet>
<servlet-name>contextLoader</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<!-- 初始化spring容器方法二 监听器版 前面有讲述-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
之后就可以通过WebApplicationContextUtils取得Spring的上下文
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(当前ServletContext);
如在struts1中,必须知道当前的servlet上下文
①WebApplicationContext ctx=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
②WebApplicationContext beanFactory=WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
如在struts2中
WebApplicationContext ctx=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
有了WebApplicationContext实例，我们就可以通过getBean方法获得spring容器中的bean了,如下所示
13.2 Strust1整合Spring的其他3种方式
在上面的Strust1中直接使用Spring，我们是通过在web.xml中配置servlet或者是listener加载和实例化spring容器。实则上
spring提供了一种专门针对于struts的插件来加载和实例化spring容器，只需在struts-config.xml加入即可，
所以我们如果不想用前面的来加载可以使用下面的
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>
<!--
注意 /WEB-INF/classes/applicationContext.xml这个位置，如果你的文件在WEB-INF。则写成/WEB-INF/applicationContext.xml
在eclipse 中 /WEB-INF/classes/applicationContext.xml对应的目录是src目录,applicationContext.xml放在src下
-->
◆使用Spring的ActionSupport类整合Structs
优点：
1) 简单
缺点：
1) 耦合高 它将Struts动作与Spring框架耦合在一起。如果您想替换掉Spring，那么您必须重写代码
2) 违反IOC
3) 无法使用 DispatchAction
◆使用Spring的DelegatingRequestProcessor覆盖Struts的RequestProcessor
DelegatingRequestProcessor方法的确比第一种方法好，缺点 RequestProcessor如果改变了怎么办或者是有不同的RequestProcessor怎么办呢
◆将Struts Action管理委托给Spring框架
动作委托解决方法是这三种方法中最好的。Struts动作不了解Spring，不对代码作任何改变就可用于非Spring应用程序中。RequestProcessor的改变不会影响它，并且它可以利用Spring AOP特性的优点。
优点
1. 动作委托解决方法是这三种方法中最好的。
2. 不使用Spring api编写 Action
3. 利用了IOC装配
三种方式的相关配置：
<1> Action直接继承ActionSupport，在Action类的execute()方法中通过
ApplicationContext ctx=getWebApplicationContext()获得Spring的
上下文，通过上下文获取相应的bean实例
<2>覆盖RequestProcessor
1.在struts-config.xml中配置控制器
<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/>
2.在applicationContext.xml文件中注册action动作bean
<bean name="/struts-config.xml配置的对应action的path" class="Action类的包名类名" >
<!--注意上面的是name而不是大家经常写的id-->
<property name="service">
<ref bean="service" /> <!--注入spring实例，假设属性名为service-->
</property>
</bean>
3.Action类中声明一个Service私有属性及其setter方法，通过IOC注入Service实例。
<3>动作管理委托给Spring
1.struts-config.xml中action标签内的type属性值替换为org.springframework.web.struts.DelegatingActionProxy,如下
<action input="/index.jsp" path="/hello" scope="session"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="success" path="/success.jsp" />
</action>
2.在applicationContext.xml文件中注册action动作bean
<bean name="/struts-config.xml配置的对应action的path" class="Action类的包名.类名" >
<property name="service">
<ref bean="service" />
</property>
</bean>
3.Action类中声明一个Service私有属性及其setter方法，通过IOC注入Service实例
13.2 Spring与Struts2的整合
由于Struts2得强大可插拔式设计，使得整合spring的工作变得异常简单，struts2-spring-plugin-2.0.8.jar就是支持spring的插件包
0.把struts2支持spring的插件包jar拷贝到项目中
1.web.xml的配置：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!-- 监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 定义Struts2的FilterDispathcer的Filter -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<!-- FilterDispatcher用来初始化struts2并且处理所有的WEB请求。 -->
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2.applicationContext.xml的配置(WEB-INF目录下)
(如果不使用默认的 则可以在web.xml通过以下配置修改xml的配置以及名称)
<!-- 加载spring 容器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/beans.xml</param-value>
</context-param>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean name="service" class="com.service.impl.ServiceImpl"/>
<!-- action的配置 -->
<bean name="abc" class="com.LoginAction" >
<property name="service">
<ref bean="service" /> <!--注入spring实例，假设action类中有一个属性名为service-->
</property>
</bean>
</beans>
3.struts.xml的配置
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-default.xml" />
<package name="default" extends="struts-default">
<!-- action标签中的class属性与applicationContext.xml中的action的bean的name属性一致 如以下的abc -->
<action name="login" class="abc">
<result name="input" >/login.jsp</result>
<result name="success">/welcome.jsp</result>
<result name="error">/failed.jsp</result>
</action>
</package>
</struts>
4.action类中声明service的一个变量及setter方法
14 Spring2.5有哪些改进
Spring2.5rc1发布了，一直想知道它葫芦里卖什么药
1 spring bean的作用域 已经有原来的单例和非单例 变成了5个
2 Jar 包：一个包分解成多个包 如 SpringMVC 不再使用spring.jar 这个庞大的包了。 Spring-webmvc.jar, spring-webmvc-portlet.jar 可以在 lib/modules 目录下找到，而且对于Struts1.* 的支持的包也应该改成 spring-webmvc-struts.jar了。
3 Hibernate：注意Spring已经不再支持Hibernate 3.1之前的版本了，也就是说2.1，3.0的版本也无法使用了。如果仍然要用的话，推荐使用Spring的2.0.6/2.0.7版本。
4． JDK版本： JDK至少要1.4.2以上，如果仍然打算使用1.3的话就请用2.0.6/2.0.7版本吧。
5． XML配置：推荐使用XML metadata格式，不过先前的DTD仍然支持。需要注意的一点是，Spring2.0的DTD继续使用“singleton”属性，但是新的Spring2.5 DTD不允许使用“singleton”属性了，改成“scope”属性来描述bean的生命周期。
6． 废弃的类与方法：有些在先前版本标注过“@deprecated”的类与方法已经完全被废弃了。
比如：
1.
ResultReader : 被 RowMapper 接口取代。
2.
BeanFactoryBootstrap : 考虑使用 BeanFactoryLocator 或自定义的bootstrap类来代替。
7． Apache OJB：注意Spring源代码中已经完全把这个去掉了，但与之整合的类仍然可以在Spring Modules project找到。https://springmodules.dev.java.net/
8． iBATIS：注意Spring已经不再支持iBATIS 的1.3版本了， 如果想继续的话，请升级到2.3以上吧。
9． JDO：注意Spring已经不支持JDO1.0了。同样，你可以升级到2.0以上版本，或者使用Spring的2.0.6/2.0.7版本。
10． UrlFilenameViewController：这个东东我也没有接触过，这里，我就简单翻译一下吧。
“考虑到嵌套路径的请求，视图名称现在决定叫UrlFilenameViewController了，这是一个突破性的改变，并且意味着如果你从Spring1.* 升级到Spring2.0 你可以使用该类从而减少Spring Web MVC的配置工作。”
15 spring 注解
<一> 1 @Autowired 2 @Autowired
@Qualifier("bean名称")
需要<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<二> JSR-250 的注释 @Resource @PostConstruct 和 @PreDestroy
加入common-annotations.jar包
需要<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
可用 <context:annotation-config/>。简化第一和第二的配置 请看下面的配置：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
<bean id="chinese" class="com.Chinese"></bean>
<bean id="American" class="com.American"></bean>
<bean id="test" class="com.Test"></bean>
</beans>
<三> @Component
Component或者@Component("bean名") @Component默认bean名为类名 首字母小写
不需要配置bean 配置文件如下
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com"/> <!--com包 这里改成你的包名-->
</beans>
以下是具体说明 高手可掠过
Spring 通过一个 BeanPostProcessor 对 注解进行解析，所以要让 注解 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。
如下
<!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
15.1 Spring 2.5 引入了 @Autowired 注解，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，按照类型进行装配
如
@Autowired
public void setP(Person p) {
this.p = p;
}
15.2 当不存在不匹配的bean或者是匹配的bean的数目大于1时，按照类型进行装配都会报出异常，可采用以下方式不报都会报出异常
@Autowired(required = false)
15.3 采用以下方式指定bean，按名字匹配
@Autowired
@Qualifier("bean名称")
用在构造方法上
@Autowired
public Test(@Qualifier("chinese")Person p) {
// TODO Auto-generated constructor stub
this.p=p;
}
15.3 使用 JSR-250 的注释 @Resource @PostConstruct 和 @PreDestroy
Spring 不但支持自己定义的 @Autowired 的注释，还支持几个由 JSR-250 规范定义的注释，它们分别是 @Resource、@PostConstruct 以及 @PreDestroy。
为了让 JSR-250 的注释生效，除了在 Bean 类中标注这些注释外，还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor：
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
@Resource
@Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，面 @Resource 默认按 byName 自动注入罢了。@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。
Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中，因此在使用之前必须将其加入到项目的类库中。
JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类，分别是 @PostConstruct 和 @PreDestroy，这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。
使用 <context:annotation-config/> 简化配置
而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是
<context:annotation-config/>。请看下面的配置：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
<bean id="chinese" class="com.Chinese"></bean>
<bean id="American" class="com.American"></bean>
<bean id="test" class="com.Test"></bean>
</beans>
<context:annotationconfig/> 将隐式地向 Spring 容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 以及 equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。
15.4 使用 @Component或者@Component("bean名") @Component默认bean名为类名 首字母小写
然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说，在 XML 配置文件中定义 Bean，通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？答案是肯定的，我们通过 Spring 2.5 提供的 @Component 注释就可以达到这个目标了。
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com"/><!--com包-->
</beans>