webx参数注入、bean创建总结

 

 

（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） 

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

2） 

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

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

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

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

<beans>
<import resource="services.xml"/>
    <import resource="resources/messageSource.xml"/>
    <import resource="/resources/themeSource.xml"/>

<bean id="bean1" class="..."/>
    <bean id="bean2" class="..."/>
</beans>

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

Object object = Class.forName(“com.spring.service.impl.PersonServiceBean”).newInstance();
BeanWrapper  beanWrapper = new BeanWrapperImpl(object);
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配置 

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

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

public interface PersonService {

    public  void save();
}
PersonServiceBean.java：
public class PersonServiceBean implements PersonService{
public void save(){
        System.out.println("Save Method is running.");
}
}

3) 测试类：SpringTest.java 

public class SpringTest {

    /**
     * @throws java.lang.Exception
     */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }
    @Test public void instanceSpring(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    PersonService personService = (PersonService)context.getBean("personService");
    personService.save();
}
}

Console执行： 
 

Save method is running.

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

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

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

public class PersonServiceBeanFactory {
    public static PersonServiceBean createPersonServiceBean(){
        return new PersonServiceBean();
    }

}

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

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

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

public class PersonServiceBeanFactory {
            public PersonServiceBean createPersonServiceBean2(){
                return new PersonServiceBean();
}
}

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: 

<bean id="personService" class="com.spring.service.impl.PersonServiceBean"
                scope="singleton" lazy-init="true" init-method="init" destroy-method="destory"
                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，分别如下： 

Mode	Desc
No	不使用自动装配，必须通过ref元素指定依赖，默认设置。
byname	根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配
byType	如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配；如果存在多个该类型bean，那么抛出异常，并指出不能使用byType方式进行自动装配；如果没有找到相匹配的bean，则什么事都不发生，也可以通过设置dependency-check="objects"让Spring抛出异常
Constructor	与byType方式类似，不同之处在于它应用于构造器参数。如果容器中没有找到与构造器参数类型一致的bean，那么抛出异常
Autodetect	通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果没有发现默认的构造器，那么将使用byType方式

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

Mode	Desc
Simple	对基本类型，字符型和集合进行依赖检查
Object	对依赖的对象进行检查
All	对全部属性进行检查
None	不进行依赖检查
Default	默认是none

如： 

< bean id="personService" class="com.spring.service.impl.PersonServiceBean"
                scope="singleton"
                autowire="autodetect" dependency-check="simple">
    <property name=”name” value=”jamson”/>
</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。