springframework 2.5引入了完整的annotaion配置注解，使用这些annotation可以大量的减少bean的定义，也使得程序开发更简单和容易维护。

当然你要使用annotation就需要使用java5以上版本。

使用annotaion定义一个bean
@Component是一个通用注解，用于说明一个类是一个spring容器管理的类。
除此之外，还有@Controller, @Service, @Repository是@Component的细化，这三个注解比@Component带有更多的语义，它们分别对应了表现层、服务层、持久层的类。
如果你只是用它们定义bean，你可以仅使用@Component，但是既然spring提供这些细化的注解，那肯定有使用它们的好处，不过在以下的例子中体现不出。

定义了一个接口

package test1;

interface MovieFinder {
    String getData();
}
定义一个实现

package test1;

import org.springframework.stereotype.Repository;

@Repository
public class JpaMovieFinder implements MovieFinder {

    @Override
    public String getData() {
        return "This is JpaMovieFinder implementation!";
    }

}
这里使用了注解@Repository，说明这是一个受spring容器管理的bean定义，这个注解没有指定bean的名字，默认为小写开头的类名，就是jpaMovieFinder，如果你要指定名字，可以这样写@Repository("myMovieFinder")。
这里也可以使用＠Component这个注解，在这里例子中体现不出用@Repository的好处。
这里没有指定这个bean的scope，缺省是singleton，如果你要其他scope，可以使用注解@Scope

@Scope("prototype")
@Repository
public class MovieFinderImpl implements MovieFinder {
    // ...
}

spring扫描并注册注解的bean
JpaMovieFinder只是添加了一个注解，这并不会自动被注册到spring容器中，我们需要告诉spring容器到那里去寻找这些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="test1"/>
    
</beans>
<context:component-scan base-package="test1"/>这个配置告诉spring容器到test1这个package下去扫描所有的类，从而找到被注解的类。
由于并不是test1下的所有的类都有注解，全部遍历效率不高，所以spring定义了过滤器用于减小扫描范围，这里为了简单起见没有使用。

使用注解进行依赖注入

package test1;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SimpleMovieLister {
   
    ＠Autowired
    private MovieFinder movieFinder;

    public String getData(String name) {
        return "Hi " + name + "! " + movieFinder.getData();
    }
   
    public MovieFinder getMovieFinder() {
        return movieFinder;
    }

    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}
SimpleMovieLister是一个服务类，它也使用了＠Service注解为了bean，这个类用到了MovieFinder，为了注入这个类的实现，这里使用了注解@Autowired，spring容器会自动找到合适的bean注入进去。注意这里并没有指定被注入bean的名字，因为spring根据只发现了一个实现，那就是jpaMovieFinder。后面，我们会看到有两个实现会怎样。

注意，上面代码使用＠Autowired时，public void setMovieFinder(MovieFinder movieFinder) 这个方法是不需要的，你可以把它删除了试一试。如果你使用xml的配置方式，该方法必须存在。我这里保留该方法，是为了后面测试注解和xml配置混合使用的方式。

测试1

package test1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("test1/beans.xml");
        SimpleMovieLister m = (SimpleMovieLister)context.getBean("simpleMovieLister");
        System.out.println(m.getData("Arthur"));
    }

}

控制台上会打印 Hi Arthur! This is JpaMovieFinder implementation!

增加MovieFinder的第二个实现

package test1;

import org.springframework.stereotype.Repository;

@Repository
public class IbatisMovieFinder implements MovieFinder {

    @Override
    public String getData() {
        return "This is IbatisMovieFinder implementation!";
    }

}

这时运行Main，系统会报错：
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'simpleMovieLister': Injection of resource fields failed; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [test1.MovieFinder] is defined: expected single matching bean but found 2: [jpaMovieFinder, ibatisMovieFinder]
从错误信息中我们可以看到现在MovieFinder有两个bean实现了，一个是jpaMovieFinder，另一个是ibatisMovieFinder，spring容器不知道应该使用哪一个bean。这时可以使用注解@Qualifier指定具体的bean。
//...
@Service
public class SimpleMovieLister {

    @Autowired
    @Qualifier("ibatisMovieFinder")
    private MovieFinder movieFinder;
//...
这里我们指定注入的是ibatisMovieFinder这个bean。
运行Main, 控制台上会打印 Hi Arthur! This is IbatisMovieFinder implementation!

Java6提供的注入注解
spring也可以使用java6提供的＠Resource注解来指定注入哪一个bean。

//...
@Service
public class SimpleMovieLister {

    @Resource(name="ibatisMovieFinder")
    private MovieFinder movieFinder;
//...
这和@Autowired功能是一致的。

使用注解还是xml
使用注解很方便，但从上面的例子我们也可以看出注解的问题，MovieFinder有两个实现，SimpleMovieLister是在程序中用注解指定了使用哪一个实现，如果要修改，需要修改源程序。所以，注解只适用于固定依赖的情况。如果依赖需要在部署的时候做调整，那还是使用xml的配置方式方便，毕竟只需要修改一下xml文件即可。

实际使用时，我们可以xml和注解两种方式混合使用。

<?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="test1"/>
   
    <bean id="simpleMovieLister1" class="test1.SimpleMovieLister">
        <property name="movieFinder" ref="jpaMovieFinder" />
    </bean>
   
</beans>
使用xml配置方式定义了另外一bean，注入了jpaMovieFinder这个实现。

package test1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("test1/beans.xml");
        SimpleMovieLister m = (SimpleMovieLister)context.getBean("simpleMovieLister");
        System.out.println(m.getData("Arthur"));
        SimpleMovieLister m1 = (SimpleMovieLister)context.getBean("simpleMovieLister1");
        System.out.println(m1.getData("Arthur"));
    }

}
simpleMovieLister是从注解来的，simpleMovieLister1是从xml配置来的。运行结果：
Hi Arthur! This is IbatisMovieFinder implementation!
Hi Arthur! This is JpaMovieFinder implementation!

证明混合使用是可行的，你可以继续测试，用xml重新配置simpleMovieLister。
因此，即使我一开始使用了注解，之后我后悔了，没有关系，不用修改源程序，以前用xml怎么配置现在还是怎么配置。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/dqatsh/archive/2008/12/08/3478000.aspx

3.完成对ContextLoaderListener的初始化以后， Tomcat开始初始化DispatchServlet，- 还记得我们在web.xml中队载入次序进行了定义。DispatcherServlet会建立自己的ApplicationContext,同时建立这个自己的上下文的时候会从ServletContext中得到根上下文作为父上下文,然后再对自己的上下文进行初始化，并最后存到 ServletContext中去供以后检索和使用。
可以从DispatchServlet的父类FrameworkServlet的代码中看到大致的初始化过程，整个ApplicationContext的创建过程和ContextLoder创建的过程相类似：

一、             概述 <o:p></o:p>

二、             Spring 初始化之旅 <o:p></o:p>

a)         Spring 初始化的时候首先要运行的类为： org.springframework.web.context. ContextLoaderListener 或 org.springframework.web.context. ContextLoaderServlet 。

       它们在初始化函数里无一例外地实例化了 ContextLoader 类 , 然后调用了它的函数      public WebApplicationContext initWebApplicationContext(ServletContext ) 。

       接下来看一下在这个方法里干了写什么

b)        在他的方法体内，关键是“ this.context = createWebApplicationContext(servletContext, parent); ”新建了一个“ ConfigurableWebApplicationContext ”类型的对象，在这一步实例化中几乎完成了所有的 spring 初始化工作。读取了所有的 spring 配置文件。它的工作步骤如下所述。

c)        首先，在将“ ConfigurableWebApplicationContext ”类型的对象实例化以后（这个对象实际的类型是这个包内的 XmlWebApplicationContext ），然后又给这个实例设置了三个属性，“ wac.setParent(parent); ”在默认的初始化过程中这一步设置了一个 null 值，然后又设置了一个“ wac.setServletContext(servletContext); ”，将系统默认的上下文设置进来，比较重要的是下面这一段：           

       if (configLocation != null) {

       // 读取 spring 的应用配置文件

       wac.setConfigLocations(StringUtils.tokenizeToStringArray(configLocation,Configurabl       eWebApplicationContext.CONFIG_LOCATION_DELIMITERS));

       }

       它将我们的配置文件名放置到 wac 变量中，以待在后续的操作中使用。然后调用           “ wac.refresh(); ”完成主要的初始化 BeanFactory 的操作。如下。

d)        首先我们应该看一下我们实例化的对象

       org.springframework.web.context.support.XmlWebApplicationContext 的类图：

<o:p> </o:p>

e)         “ wac.refresh(); ”从类结构里我们能找到这个方法来自它的父类： AbstractApplicationContext 在它的 refresh() 方法内我们可以看到 spring 的复杂逻辑。

       首先执行了 refreshBeanFactory(); （来自 AbstractRefreshableApplicationContext ）见 f),

f)         refreshBeanFactory(); 这个方法由负责维护变量 beanFactory 的子类 AbstractRefreshableApplicationContext 实现，默认情况下这个方法直接实例化一个新的 DefaultListableBeanFactory 类型的 BeanFacorty, 然后调用一个起缓冲作用的配置函数生成一个将 beanFacroty 包装起来的对象 beanDefinitionReader ，然后对这个对象进行属性配置，实际上该方法主要负责生成一个临时的操作对象，对应调用的函数为“ loadBeanDefinitions(beanFactory); ”该方法为初始化期间较为重要的一个。        该方法来自其子类： AbstractRefreshableWebApplicationContext 对应的函数：

protected void loadBeanDefinitions(DefaultListableBeanFactory) ，然后这里又调用了自己定义的 protected void loadBeanDefinitions(XmlBeanDefinitionReader) 方法。此时，它就使用到了在 c) 中设置了的（ wac.setConfigLocations(……)) 我们开发中密切相关的配置文件。（同时也要记住此时这个函数的参数 beanDefinitionReader ，之前已经设置了“ beanDefinitionReader.setResourceLoader(this); ”这里的 this 是我们在前面见到的 XmlWebApplicationContext （一个定义好了的上下文））。接着往下：

       “ reader.loadBeanDefinitions(configLocations[i]); ” reader 开始加载我们配置文件内的东西了，不过真正复杂的实现此时才开始，我们继续往下走，在接下来的方法内默认情况下会执行：

if (resourceLoader instanceof ResourcePatternResolver) （该判断条件为 true ） , 由于从上面我们知道： beanDefinitionReader.setResourceLoader(this); 而 this 的类型为： XmlWebApplicationContext 所以 ((ResourcePatternResolver) resourceLoader).getResources(location); 得到一个 Resource[] 数组，接下来调用：

int loadCount = loadBeanDefinitions(resources); 该函数继续调用自己子类定义的一系列临时接口最终执行到 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); 在这个函数内初始化了处理 xml 文件的一些对象并将用户的配置文件解析为一个 Document 对象。然后又执行了一系列函数直到

return parser.registerBeanDefinitions(this, doc, resource); 这个函数来自我们新建的 DefaultXmlBeanDefinitionParser ，在这个类里最终执行了对 xml 文件的解析工作和对 beanFacroty 变量执行了设置工作。

g)        终于我们从这些繁杂的逻辑中跳了出来，继续执行 AbstractApplicationContext.refresh() 下面的工作，后续的代码主要仍旧是往一些常量里面设值。

此时 spring 初始化过程就结束了

评述：启动过程如下：
1.创建一个ApplicationContext的实例ac
2.读取配置文件，ac简单的设置（比如有多少bean）
3.所有的beanfactory后处理开始以此执行
4.开始创建bean的实例
5.进行注入（如果有其他bean，迭代执行）
6.如何实现一些接口（BeanFactoryAware, BeanNameAware）以此该bean执行相应方法
7.所有的bean后处理开始执行,中间如果实现InitializingBean，该bean执行相应方法）

2． 依赖容器的参数化事务管理
通过容器提供的集约式参数化事务机制，实现事务的外部管理，如EJB 中的事务管理模式。
 容器管理的参数化事务为程序开发提供了相当的灵活性，同时因为将事务委托给容器进行管理，
应用逻辑中无需再编写事务代码，大大节省了代码量（特别是针对需要同时操作多个事务资源的应用），从而提高了生产率。

    比如生产环境的jdbc.properties里定义了jdbc连接为Oracle，并通过PlaceholderConfigurer设置到<bean id="dataSource"> 里，在测试时再载入下面的applicationContex-test.xml文件，就能透明的将配置更改为嵌入式数据库。

applicationContext-test.xml: 定义载入的properties。

<bean id="testPropertyConfigurer" class="org.springframework.beans.factory.config.PropertyOverrideConfigurer">
<property name="location" value="classpath:spring/test/jdbc.properties"/>
</bean>

spring/test/jdbc.properties: 将ApplicationContext 中id为dataSource的bean的url属性改为使用hsqldb。

你可以通过下列途径学习spring：

(1) spring下载包中doc目录下的MVC-step-by-step和sample目录下的例子都是比较好的spring开发的例子。

(2) AppFuse集成了目前最流行的几个开源轻量级框架或者工具Ant,XDoclet,Spring,Hibernate(iBATIS),JUnit,Cactus,StrutsTestCase,Canoo's WebTest,Struts Menu,Display Tag Library,OSCache,JSTL,Struts 。

你可以通过AppFuse源代码来学习spring。

AppFuse网站：http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse

(3)Spring 开发指南(夏昕)（http://www.xiaxin.net/Spring_Dev_Guide.rar）

一本spring的入门书籍,里面介绍了反转控制和依赖注射的概念，以及spring的bean管理，spring的MVC，spring和hibernte，iBatis的结合。

(4) spring学习的中文论坛

SpringFramework中文论坛(http://spring.jactiongroup.net)

Java视线论坛(http://forum.javaeye.com)的spring栏目

2、利用Spring框架编程，console打印出log4j:WARN Please initialize the log4j system properly？

说明你的log4j.properties没有配置。请把log4j.properties放到工程的classpath中，eclipse的classpath为bin目录，由于编译后src目录下的文件会拷贝到bin目录下，所以你可以把log4j.properties放到src目录下。

这里给出一个log4j.properties的例子：

log4j.rootLogger=DEBUG,stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

3、出现 java.lang.NoClassDefFoundError?

一般情况下是由于你没有把必要的jar包放到lib中。

比如你要采用spring和hibernate（带事务支持的话），你除了spring.jar外还需要hibernat.jar、aopalliance.jar、cglig.jar、jakarta-commons下的几个jar包。

http://www.springframework.org/download.html下载spring开发包，提供两种zip包
建议你下载开发包。这个zip解压缩后比后者多一个lib目录，其中有hibernate、j2ee、dom4j、aopalliance、jakarta-commons等常用包。

4、java.io.FileNotFoundException: Could not open class path resource [....hbm.xml],提示找不到xml文件？

原因一般有两个：

(1)该xml文件没有在classpath中。

(2)applicationContext-hibernate.xml中的xml名字没有带包名。比如：

User.hbm.xml 错，改为： com/yz/spring/domain/User.hbm.xml

net.sf.hibernate.dialect.MySQLDialect true

5、org.springframework.beans.NotWritablePropertyException: Invalid property 'postDao' of bean class？

出现异常的原因是在application-xxx.xml中property name的错误。 中name的名字是与bean的set方法相关的，而且要注意大小写。

比如

public class PostManageImpl extends BaseManage implements PostManage {

private PostDAO dao = null;

public void setPostDAO(PostDAO postDAO){

this.dao = postDAO;

}

}

那么xml的定义应该是：

对 错

6、Spring中如何实现事务管理？

首先，如果使用mysql，确定mysql为InnoDB类型。

事务管理的控制应该放到商业逻辑层。你可以写个处理商业逻辑的JavaBean，在该JavaBean中调用DAO，然后把该Bean的方法纳入spring的事务管理。

比如：xml文件定义如下：

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED

com.yz.spring.service.implement.UserManageImpl就是我们的实现商业逻辑的JavaBean。我们通过parent元素声明其事务支持。

7、如何管理Spring框架下更多的JavaBean？

JavaBean越多，spring配置文件就越大，这样不易维护。为了使配置清晰，我们可以将JavaBean分类管理，放在不同的配置文件中。 应用启动时将所有的xml同时加载。

比如：

DAO层的JavaBean放到applicationContext-hibernate.xml中，商业逻辑层的JavaBean放到applicationContext-service.xml中。然后启动类中调用以下代码载入所有的ApplicationContext。
String[] paths = {"com/yz/spring/dao/hibernate/applicationContext-hibernate.xml",

"com/yz/spring/service/applicationContext-service.xml"};

ctx = new ClassPathXmlApplicationContext(paths);

8、web应用中如何加载ApplicationContext？

可以通过定义web.xml，由web容器自动加载。

context

org.springframework.web.context.ContextLoaderServlet

1

contextConfigLocation /WEB-INF/applicationContext-hibernate.xml /WEB-INF/applicationContext-service.xml

9、在spring中如何配置的log4j?

在web.xml中加入以下代码即可。

log4jConfigLocation /WEB-INF/log4j.properties

10、Spring框架入门的编程问题解决了，我该如何更深地领会Spring框架呢？

这两本书你该去看看。这两本书是由Spring的作者Rod Johnson编写的。

Expert One on one J2EE Design and Development

Expert One on one J2EE Development Without EJB

你也该看看martinfowler的Inversion of Control Containers and the Dependency Injection pattern。

http://www.martinfowler.com/articles/injection.html

再好好研读一下spring的文档。

http://www.jactiongroup.net/reference/html/

大家可能在spring中经常看到这样的定义：

<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop><prop key="store*">PROPAGATION_REQUIRED</prop>

估计有好多朋友还没有弄清楚里面的值的意思，仔细看完下面应该知道自己什么情况下面应该使用什么样的声明。^_^

Spring中常用事务类型：

• PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
• PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
• PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
• PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
• PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
• PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
• PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
  

EJB的事务类型：

Nerver :        不参与事务,如果参与产生RemoteException
NotSupported:   不能参与
Supports:       如果调用者正在参与事务,相应的EJB调用也可以参与事务,否则不能
Mandatory       如果调用者有一个事务,相应的EJB可以参与事务,否则,TransactionRequiredException
Required        如果调用者有一个事务,相应的EJB可以参与事务,否则,容器将在调用相应的EJB之前,开始一个事务.
                当方法调用完成以后,即提交该事务.
RequiresNew     在调用相应的EJB之前,开始一个新的事务,当方法调用返回时,即提交这个事务.

　　前六个策略类似于EJB CMT：常量名相同，因此，对EJB开发人员来说，应该立刻就感到熟悉。第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager），或者通过JTA支持嵌套事务。

　　事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。

　　在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。

大量采用了callback的机制.
jdbcTemplate.update(...)
jdbcTemplate.query(...)
jdbcTemplate.call(...)

1． 代码控制的事务管理
简单配置事务,然后在代码中使用TransactionTemplate.

2． 参数化配置的事务管理
采用proxy模式,简单!!!!

(2)hibernate in spring
与上面JDBC中的配置相对比，区别主要在于：
1． SessionFactory的引入
Hibernate中通过SessionFactory创建和维护Session。Spring对
SessionFactory的配置也进行了整合，无需再通过Hibernate.cfg.xml对
SessionFactory进行设定。
SessionFactory节点的mappingResources属性包含了映射文件的路径，list
节点下可配置多个映射文件。
hibernateProperties节点则容纳了所有的属性配置。
可以对应传统的Hibernate.cfg.xml文件结构对这里的SessionFactory配置
进行解读。
2． 采用面向Hibernate的TransactionManager实现：
org.springframework.orm.hibernate.HibernateTransactionManag
er

public class UserDAO extends HibernateDaoSupport implements IUserDAO
{
   public void insertUser(User user) {
      getHibernateTemplate().saveOrUpdate(user);
   }
}
(3)ibatis in spring
对比之前的JDBC和Hibernate配置，可以看到：
1． sqlMapClient节点
SpringFrameWork Developer’s Guide Version 0.6
类似SessionFactory之与Hibernate，这里我们引入了针对ibatis SqlMap的
SqlMapClientFactoryBean配置。SqlMapClient对于ibatis的意义类似于Session
与Hibernate以及Connection与JDBC，这里的sqlMapClient节点实际上配置了一
个sqlMapClient的创建工厂类。
configLocation属性配置了ibatis映射文件的名称。
2． transactionManager节点
这里我们的transactionManager配置与之前JDBC示例中相同，都采用了
DataSourceTransactionManager，这与Hibernate有些差异。
3． userDAO节点
对应的，UserDAO需要配置两个属性，sqlMapClient和DataSource，
sqlMapClient将从指定的DataSource中获取数据库连接。
其他配置基本上与JDBC示例中相同，这里就不加赘述

(1)与Spring MVC中的Command对象不同，Webwork 中的Model对象，扮演着承上启下
的角色，它既是Action的输入参数，又包含了Action处理的结果数据。
换句话说，输入的Http请求参数，将被存储在Model对象传递给Action进行处理，Action
处理完毕之后，也将结果数据放置到Model 对象中，之后，Model 对象与返回界面融合生
成最后的反馈页面。

(2)注意这里与Spring MVC 不同，Spring MVC 会自动为逻辑处理单元创建
Command Class实例，但Webwork不会自动为Action创建Model对象实例，
Model 对象实例的创建需要我们在Action 代码中完成（如LoginAction 中
LoginInfo对象实例的创建）。

(3)

(4)

 <welcome-file-list>
        <welcome-file>/web/login/index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

 <!---Action Definition-->
 <bean id="LoginAction" class="com.jason.action.LoginAction">
  <property name="commandClass">
   <value>com.jason.form.LoginInfo</value>
  </property>
  <property name="fail_view">
   <value>loginfail</value>
  </property>
  <property name="success_view">
   <value>main</value>
  </property>
 </bean>
</beans>

<html>
<body>
 <form method="POST" action="./login.do">          //这个地方. 指向当前路径
  <p align="center">登录</p><br>
   用户名:<input type="text" name="username" >
  <br>
   密   码:<input type="password" name="password" >
  <br>
  <p>
   <input type="submit" value="提交" name="B1">
   <input type="reset" value="重置" name="B2">
  </p>
 </form>
</body>
</html>

LoginAction
package com.jason.action;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

//导入的时候，之前选择错误
import org.springframework.validation.BindException;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;                       

import com.jason.form.LoginInfo;

public class LoginAction extends SimpleFormController {
 
 private String fail_view;
 private String success_view;
 
 protected ModelAndView onSubmit(Object cmd, BindException ex)
 throws Exception {
  LoginInfo loginInfo = (LoginInfo) cmd;
  if (login(loginInfo) == 0) {
   HashMap result_map = new HashMap();
   result_map.put("logininfo", loginInfo);
   List msgList = new LinkedList();
   msgList.add("msg1");
   msgList.add("msg2");
   msgList.add("msg3");
   result_map.put("messages", msgList);
   return new ModelAndView(this.getSuccess_view(), result_map);
  } else {
   return new ModelAndView(this.getFail_view());
  }
  //return new ModelAndView(new RedirectView(“/redirected.jsp”));
 }
 private int login(LoginInfo loginInfo) {
  if ("Erica".equalsIgnoreCase(loginInfo.getUsername())
    && "mypass".equals(loginInfo.getPassword())) {
   return 0;
  }
  return 1;
 }
 public String getFail_view() {
  return fail_view;
 }
 public String getSuccess_view() {
  return success_view;
 }
 public void setFail_view(String string) {
  fail_view = string;
 }
 public void setSuccess_view(String string) {
  success_view = string;
 }
 
}

LoginInfo
package com.jason.form;

import java.io.Serializable;

public class LoginInfo implements Serializable {
 private String username;
 private String password;
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
}


【注】调试的时候因为导入的类选择错误引起问题，要注意！！！

(1)Type1 接口注入
加载接口实现并创建其实例的工作由容器完成。在运行期，***实例将由容器提供。

public class MyServlet extends HttpServlet {
    public void doGet(
    HttpServletRequest request,
    HttpServletResponse response)
    throws ServletException, IOException {
       ……
    }
}
这也是一个Type1 型注入，HttpServletRequest和HttpServletResponse实例由Servlet Container在运行期动态注入。

(2)Type2 设值注入

(3)Type3 构造子注入
构造子注入，即通过构造函数完成依赖关系的设定，如：

public class DIByConstructor {
   private final DataSource dataSource;
   private final String message;
   public DIByConstructor(DataSource ds, String msg) {
    this.dataSource = ds;
    this.message = msg;
    }
……
}

Type2 设值注入的优势
 1． 对于习惯了传统JavaBean开发的程序员而言，通过setter方法设定依赖关系显得更加直
 观，更加自然。
 2． 如果依赖关系（或继承关系）较为复杂，那么Type3模式的构造函数也会相当庞大（我们需
 要在构造函数中设定所有依赖关系），此时Type2模式往往更为简洁。
 3． 对于某些第三方类库而言，可能要求我们的组件必须提供一个默认的构造函数（如Struts
 中的Action），此时Type3类型的依赖注入机制就体现出其局限性，难以完成我们期望的功
 能。

Type3 构造子注入的优势：
 1． “在构造期即创建一个完整、合法的对象”，对于这条Java设计原则，Type3无疑是最好的
 响应者。
 2． 避免了繁琐的setter方法的编写，所有依赖关系均在构造函数中设定，依赖关系集中呈现，
 更加易读。
 3． 由于没有setter方法，依赖关系在构造时由容器一次性设定，因此组件在被创建之后即处于
 相对“不变”的稳定状态，无需担心上层代码在调用过程中执行setter方法对组件依赖关系
 产生破坏，特别是对于Singleton模式的组件而言，这可能对整个系统产生重大的影响。
 4． 同样，由于关联关系仅在构造函数中表达，只有组件创建者需要关心组件内部的依赖关系。
 对调用者而言，组件中的依赖关系处于黑盒之中。对上层屏蔽不必要的信息，也为系统的
 层次清晰性提供了保证。
 5． 通过构造子注入，意味着我们可以在构造函数中决定依赖关系的注入顺序，对于一个大量
 依赖外部服务的组件而言，依赖关系的获得顺序可能非常重要，比如某个依赖关系注入的
 先决条件是组件的DataSource及相关资源已经被设定。