（1）分类

参数注入分为两种：

              1.作为类的属性注入

这就是spring最典型的注入方式，通过@Autowired和@Resource进行注入

              2.作为方法的入参注入

webx中的@Param，@FormData等

public class LoginAction {  @Autowired  private LoginService loginService; // 一般性注入  @Autowired  private HttpSession session;      // 特殊注入  public void doLogin(@Param("name") String name, @Param("password") String password,  @Param("return") String returnURI, Context context, Navigator navigator) {// 参数注入  if (loginService.login(name, password)) {  session.setAttribute(Constant.SESSION_KEY, "true");  navigator.redirectToLocation(returnURI);  } else {  context.put("message", "用户名、密码错误！");  }  }
}  

（2）注入内容

              1.一般类实例

如上面的LoginService是我们自定义的，可以直接注入。这与一般的spring依赖注入完全一致

              2.特殊实例

如HttpSession、HttpServletRequest等特殊实例，webx进行了处理，可以直接注入到类中

          3.方法参数

请求中所带的参数，可以直接解析后作为方法参数传递进去，否则就必须自己解析，如：

//传统的写法
public void execute(Rundata rundata, Context context) {  String name = rundata.getParameters().getString("name");  context.put("name", name);
}
//使用参数注入之后的写法
public void execute(@Param("name") String name, Context context) {  context.put("name", name);  }  

（3）注入配置

          1.总体配置

直接在webx-component-and-root.xml中加入

<services:data-resolver>  <dr-factories:turbine-rundata-resolver />  <dr-factories:parameter-resolver />  <dr-factories:form-resolver />
</services:data-resolver>  

    2.turbine-rundata-resolver

也就是说可以注入TurbineRundata相关数据，即请求上下文相关的数据。类型包括

* <ul>
* <li>TurbineRunData</li>
* <li>HttpServletRequest</li>
* <li>HttpServletResponse</li>
* <li>HttpSession</li>
* <li>ServletContext</li>
* <li>ParameterParser</li>
* <li>CookieParser</li>
* <li>Context</li>
* <li>RequestContext及其子类</li>
* <li>Context中的值，需要指定<code>@ContextValue("name")</code>注解。</li>
* </ul>  

实例：

void doGetRundata(TurbineRunData rundata)
void doGetNavigator(Navigator nav)
void doGetContext(Context context)
void doGetRequestContext(RequestContext requestContext)

          3.parameter-resolver

使得可以使用@Param、@Params注解注入参数

@Param用法：

<1>仅指定参数名称 ：@Param("name")

实例：

void doGetInt(@Param("aaa") int i)  

<2>指定参数名称并包含一个默认值 ：@Param(name="name",defaultValue="123")

实例：

void doGetIntDefault(@Param(name = "aaa", defaultValue = "123") Integer i)  

<3>指定参数名称并包含一组默认值 ：@Param(name="name",defaultValues={"1","2","3"})

实例：

void doGetIntegerArrayDefault(@Param(name = "aaa", defaultValues = { "123", "456" }) Integer[] i)  

@Params用法：

将request parameters中的值放入pojo中

实例：

void doSetData(@Params MyData data)  

 4.form-resolver

使得可以使用@FormData等表单相关注解进行参数注入

关键字 
BeanFactory 
ApplicationContext 
创建Bean的三种方法 
Bean的作用域 
Bean的生命周期 
Bean的XML元数据配置 
自动扫描管理Bean

对于Spring框架开发而言，BeanFactory和ApplicationContext无疑是最基础的两个类。那么这篇文章就介绍下。 
一 BeanFactory 
   接口BeanFactory(org.springframework.beans.BeanFactory)，其职责是：处理Bean的初始化，定位，配置应用程序中的对象以及建立这些对象的依赖。Bean对象的依赖是通过元数据来描述。通过BeanFactoryAware类实现。比较常用的子接口为XMLBeanFactory。 
对于单个文件的读取方法有如下两种： 
1）

Java代码  

1. Resource resource = new FileSystemResource(“beans.xml”);
2. BeanFactory factory = new XmlBeanFactory(resource);

2）

Java代码  

1. ClassPathResource resource = new ClassPathResource(“beans.xml”);
2. BeanFactory factory = new XmlBeanFactory(resource);

当需要从多个文件中加载一个BeanFactory实例时候，可以像如下使用:

Java代码  

1. ApplicationContext ctx= new ClassPathXmlApplicationContext(new String[]{“beans.xml”,”application.xml”});
2. BeanFactory  factory =ctx;

而Bean Factory通过Bean definition reader从多个文件中读取Bean定义，这样的话，我们可以这么处理，即组成基于XML配置元数据可以做如下配置：

Xml代码  

1. <beans>
2. <import resource="services.xml"/>
3. <import resource="resources/messageSource.xml"/>
4. <import resource="/resources/themeSource.xml"/>
5. <bean id="bean1" class="..."/>
6. <bean id="bean2" class="..."/>
7. </beans>

要求在完成bean定义之前导入所有的XML文件。 
在BeanFactory中，与之关联最重要的类是：BeanWrapper。

Java代码  

1. Object object = Class.forName(“com.spring.service.impl.PersonServiceBean”).newInstance();
2. BeanWrapper  beanWrapper = new BeanWrapperImpl(object);
3. beanWrapper.setPropertyValue(“name”, “Jamson”);

通过BeanWrapper，我们可以无需在编码时就指定JavaBean的实现类和属性值，通过在配置文件加以设定，就可以在运行期动态创建对象并设定其属性(依赖关系）.

二 ApplicationContext 
   接口ApplicationContext来自于org.springframework.context.ApplicationContext,继承BeanFactory，除了支持BeanFactory的功能外，还能支持企业应用的其它功能，如：事务管理，国际化支持，以及AOP集成等等。通过类ApplicationContextAware类实现。比较常用的子接口为：AbstactApplicationContext。 
例如： 
ApplicationContext ctx = new ClassPathXmlApplicationContext(“application.xml”); 
对于多个XML配置文件来读取一个ApplicationContext实例时，可以这样使用: 
1） ApplicationContext ctx= new ClassPathXmlApplicationContext(new String[]{“beans.xml”,”application.xml”}); 
2） ApplicationContext context = new FileSystemXmlApplicationContext("c:/foo.xml");---不推荐使用 
3） XmlApplicationContext：用来读取包含一个WebAppliction中的XML文件。

ApplictionContext的关闭，通过调用AbstractApplicationContext.close()来执行。而BeanFactory的关闭，可以通过destroy-method=”method”来实现。 
三 创建bean的三种方法 
1. 类构造器 
如:<bean id=”personService” class=”com.spring.service.impl.PersonServiceBean”/> 
下面给出一个Sample: 
1) beans.xml配置

Xml代码  

1. <bean id=”personService” class=”com.spring.service.impl.PersonServiceBean”/>

2) PersonService.java/PersonServiceBean.java 
PersonService.java:

Java代码  

1. public interface PersonService {
2. public  void save();
3. }
4. PersonServiceBean.java：
5. public class PersonServiceBean implements PersonService{
6. public void save(){
7. System.out.println("Save Method is running.");
8. }
9. }

3) 测试类：SpringTest.java

Java代码  

1. public class SpringTest {
2. /**
3. * @throws java.lang.Exception
4. */
5. @BeforeClass
6. public static void setUpBeforeClass() throws Exception {
7. }
8. @Test public void instanceSpring(){
9. ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
10. PersonService personService = (PersonService)context.getBean("personService");
11. personService.save();
12. }
13. }

Console执行：

Log代码  

1. Save method is running.

当然，在这个方法被调用之前，构造函数和init()方法都已经被调用。 
2. 静态工厂(Static  Factory) 
如: <bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-method=”createPersonServiceBean”/> 
1) beans.xml:

Xml代码  

1. <bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-method=”createPersonServiceBean”/>

2) PersonService.java和PersonServiceBean.java同上 
3) PersonServiceBeanFactory.java

Java代码  

1. public class PersonServiceBeanFactory {
2. public static PersonServiceBean createPersonServiceBean(){
3. return new PersonServiceBean();
4. }
5. }

4) SpringTest.java:同上 
3. 实例工厂 
如: <bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-bean=”PersonServiceBeanFacotory”  factory-method=”createPersonServiceBean”/> 
1) beans.xml:

Xml代码  

1. <bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-bean=”PersonServiceBeanFacotory”  factory-method=”createPersonServiceBean”/>

2)  PersonService.java和PersonServiceBean.java同上 
3)  PersonServiceBeanFactory.java

Java代码  

1. public class PersonServiceBeanFactory {
2. public PersonServiceBean createPersonServiceBean2(){
3. return new PersonServiceBean();
4. }
5. }

4) SpringTest.java:同上 
四 Bean的作用域 
Bean的作用域在Spring中主要用到两个：Singleton(默认)和Prototype。 
1． Singleton： 
对于每个Spring Ioc容器而言，每个bean定义只有一个对象实例，这同Java对象中的Singleton不一样。在Spring中，singleton是基于Spring Ioc容器这个Level，而java中是针对与JVM这个Level。默认情况下，系统会在容器启动的时候加载，即在容器加载完成后去调用该Bean的默认构造函数。当然，可以在bean.xml中配置延迟加载(Lazy-init=”true”),或者是要求所有的bean都使用延迟加载(default-lazy-init=”true”). 
2． Prototype： 
对于Prototype而言，每次都会创建一个新的对象实例。而Bean的实例化是在调用getBean方法时。 
五 Bean的生命周期 
Bean是由Spring容器初始化，装配和管理的对象。Bean的生命周期主要是： 
1) Bean实例化 
Bean的默认构造函数。 
2) Bean的初始化 
Init()方法中可以进行初始化。 
3) Bean的使用 
getBean()方法可以获取当前的Bean，从而做相对应的业务操作。 
4) Bean的销毁 
destroy()方法执行bean的销毁。 
六 Bean的XML元数据配置 
   对于所有的Bean配置，我们都是在XML中完成。所有的Bean属性配置可以参考http://www.springframework.org/schema/beans/spring-beans-2.5.xsd。 
详细内容请看下面的一个Sample:

Xml代码  

1. <bean id="personService" class="com.spring.service.impl.PersonServiceBean"
2. scope="singleton" lazy-init="true" init-method="init" destroy-method="destory"
3. autowire="autodetect" dependency-check="simple">

1. Scope： 
这里同Web应用中的Scope一样，但是在Spring中，Singleton和Prototype是常用的Value。 
2. Init-method: 
就是初始化Bean时调用的方法 
3. Destroy-method: 
就是Bean销毁时候指定调用的方法 
4. Autowire 
Autowire:对应有五个Value，分别如下：

可以设置bean使自动装配失效： 
采用xml格式配置bean时,将<bean/>元素的autowire-candidate属性设置为false,这样容器在查找自动装配对象时,将不考虑该bean,即它不会被考虑作为其它bean自动装配的候选者,但是该bean本身还是可以使用自动装配来注入其它bean的. 
不过，在日常的开发中，一般都是进行手工装配，很少用自动装配，因为手工装配易于开发管理。 
5. Dependency-check 
Dependency-check属性是同autowire属性一同使用，也就是说，只有在使用自动装载的时候，才会发挥作用。主要有四个Value:

如：

Xml代码  

1. < bean id="personService" class="com.spring.service.impl.PersonServiceBean"
2. scope="singleton"
3. autowire="autodetect" dependency-check="simple">
4. <property name=”name” value=”jamson”/>
5. </bean>

是不能被子Bean所继承。 
6. Abstract 
Value值对应有true和false.一个bean组件没有指定实现类，而是通过设置abstract="true"属性来组织spring 容器实例化组件.abstract="true",表明这个bean只能作为其他bean的父bean使用，不能直接被实例化。 
7. Factory-bean 
只有使用实例工厂实例化bean的场合。 
8. Factory-method 
在使用非构造器方式实例化bean的场合。 
9. 关于Collection的实例化

七 自动扫描管理Bean 
   自动扫描管理Bean，主要分为以下步骤： 
1. XML配置 
<context:component-scan base-package=”com.spring”/> 
告诉Spring容器，在com.spring包包含子包下所有的Bean都委托给Spring容器扫描管理。 
2. Bean的注解 
对于Spring引入的注解有四种：@Service，@Controller，@Repository，@Component。 
对于@Service，用于标注业务层组件。 
对于@Controller，用于标注控制层组件。 
对于@Repository, 用于标注数据访问层组件(即Dao层)； 
对于@Component，用于标注所有的组件，通常用于一个不宜归于上述三种组件类型的Bean组件。 
更多详细的设置，可以参考：http://www.springframework.org/schema/context/spring-context-2.5.xsd。