struts2 spring注解

在《Spring揭秘》中对Scope的解释是：

Scope用来声明容器中的对象所应该处的限定场景或者说该对象的存活时间，即容器在对象进入其相应的scope之前生成并装配这些对象，在该对象不再处于这些scope的限定之后，容器通常会销毁这些对象。

所以在Spring注解开发中@Scope注解可以用于设置组件的作用域，通过@Scope源码，可以发现@Scope注解有四种作用域，即

1. SINGLETON:单例模式，默认模式，不写的时候默认是SINGLETON
2. PROTOTYPE:原型模式
3. REQUEST:同一次请求则只创建一次实例
4. SESSION:同一个session只创建一次实

@Scope源码：

/**
   * Specifies the name of the scope to use for the annotated component/bean.
   * <p>Defaults to an empty string ({@code ""}) which implies
   * {@link ConfigurableBeanFactory#SCOPE_SINGLETON SCOPE_SINGLETON}.
   * @since 4.2
   * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE
   * @see ConfigurableBeanFactory#SCOPE_SINGLETON
   * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST
   * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION
   * @see #value
   */
  @AliasFor("value")
  String scopeName() default "";

1、SINGLETON
SINGLETON是IOC容器默认的作用域，所以写和不写没有区别。当作用域为SINGLETON的时候，在Spring的IOC容器从创建到退出都只会存在一个实例，所有对该对象的引用将共享这个实例。该实例从容器启动，并因为第一次被请求而初始化后，将一直存活到容器退出，也就是说，它与IoC容器的寿命“几乎”相同。
1)、新建一个实体类

package com.xinyi.bean;
public class Person {
  private String name;
  private Integer age;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public Integer getAge() {
    return age;
  }
  public void setAge(Integer age) {
    this.age = age;
  }
  @Override
  public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
  }
  public Person(String name, Integer age) {
    super();
    this.name = name;
    this.age = age;
  }
  public Person() {
  }
}

2)、新建一个配置类：

package com.xinyi.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import com.xinyi.bean.Person;
@Configuration
public class MyConfig1 {
  //默认单实例,可以不写
  @Scope("SINGLETON")
  @Bean("person")
  public Person person() {
    System.out.println("IOC容器中注入person实例");
    return new Person("李青",18);
  }
}

3)、新建一个测试类：

package com.xinyi.test;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.xinyi.config.MyConfig1;
public class IOCTest {
  @Test
  public void test2() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig1.class);
  }
}

上述代码输出的结果为：

说明在ioc容器启动的时候就已经创建了person实例，因为当作用域为SINGLETON的时候，在Spring的IOC容器从创建到退出都只会存在一个实例，所有对该对象的引用将共享这个实例。所以在test2中添加代码：

Object person1 = applicationContext.getBean("person");
    Object person2 = applicationContext.getBean("person");
    System.out.println(person1 == person2);

则输出结果为true。表明person1和person2引用的都是同一个实例。
当作用域为singleton，在ioc容器创建完成的时候就创建bean的实例，这时可以通过@lazy注解，进行bean的懒加载，即在ioc容器创建完成的时候并不生成bean的实例，只有当调用实例的时候才生成实例。
当为singleton时，实现如下测试方法：

@Test
  public void test2() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig1.class);
    System.out.println("IOC容器创建完成");

输出结果如下：

即ioc容器创建的时候同时生成了bean的实例，这时在配置类中添加@lazy注解：

@Configuration
public class MyConfig1 {
  //默认单实例
  @Bean("person")
  @Lazy
  public Person person() {
    System.out.println("IOC容器中注入person实例");
    return new Person("李青",18);
  }
}

输出结果如下：

只创建了ioc容器，并未生成bean实例，这时如果调用实例，则bean实例才会创建，并且person1和person2引用的是同一个实例对象：

@Test
  public void test2() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig1.class);
    System.out.println("IOC容器创建完成");
    Object person1 = applicationContext.getBean("person");
    Object person2 = applicationContext.getBean("person");
    System.out.println(person1 == person2);
  }

2)、PROTOTYPE
将上面配置类代码中的scope的值改为：PROTOTYPE

public class MyConfig1 {
  //将作用域ss设置为原型模式
  @Scope("prototype")
  @Bean("person")
  public Person person() {
    System.out.println("IOC容器中注入person实例");
    return new Person("李青",18);
  }
}

执行测试类代码，并无输出结果，则说明在IOC容器启动的时候并不会调用方法创建实例放入到IOC容器中，则再添加根据id获取对象的方法：

Object person1 = applicationContext.getBean(“person”);
Object person2 = applicationContext.getBean(“person”);
System.out.println(person1 == person2);

启动测试类，输出结果：

可见创建了两次实例，并且person1==person2的值也为false，说明当作用域为prototype时，每次获取对象的时候都会调用方法创建实例。

在进行spring注解开发的时候，作用域使用较多的即singleton和prototype两种作用域，request和session则使用的较少。
request表示在HTTP请求中，每一个Bean定义对应一个实例，request作用域仅在基于web的spring上下文中才有效，例如springmvc。
session表示在HTTP Session中，每一个Bean定义对应一个实例，request作用域仅在基于web的spring上下文中才有效，例如springmvc。

以上就是如何通过@Scrope注解设置组件的作用域，以及分析了几种不同作用域参数。