Spring-Bean 作用域

作用域

作用域案例

public class BeanScopeDemo {
    @Autowired
    @Qualifier("singletonPerson")
    Person person;

    @Autowired
    @Qualifier("prototypePerson")
    Person person1;

    @Autowired
    @Qualifier("prototypePerson")
    Person person2;

    @Autowired
    Set<Person> personSet;
    /**
     * 创建bean
     * @return
     */
    public static Person createPerson(){
        Person person = new Person();
        person.setId(System.currentTimeMillis());
        person.setName(System.currentTimeMillis()+"");
        return person;
    }

    /**
     * 查找
     * @param context
     */
    public static void scopeBeanLookUp(AnnotationConfigApplicationContext context){
        for (int i = 0; i < 3; i++) {
            Person prototypePerson = context.getBean("prototypePerson", Person.class);
            System.out.println("prototypePerson" + prototypePerson);
            Person singletonPerson = context.getBean("singletonPerson", Person.class);
            System.out.println("singletonPerson" + singletonPerson);
        }
    }
    private static void scopedBeansByInjection(AnnotationConfigApplicationContext context) {
        BeanScopeDemo bean = context.getBean(BeanScopeDemo.class);
        System.out.println(bean.person);
        System.out.println(bean.person1);
        System.out.println(bean.person2);
        System.out.println(bean.personSet);
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(BeanScopeDemo.class);
        context.refresh();
        scopeBeanLookUp(context);
        scopedBeansByInjection(context);
        context.close();
    }

    /**
     * 默认scope 就是singleton
     * @return
     */
    @Bean
    public static Person singletonPerson(){
        return createPerson();
    }
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public static Person prototypePerson(){
        return createPerson();
    }
}

运行结果：

结论：
1 singleton Bean 无论依赖查找还是依赖注入，均为同一个对象
2 prototype Bean 无论依赖查找还是依赖注入，均为新生成的对象
3 如果为集合类型，则单例和原型对象各一个

单例模式和原型模式生命周期的不同

public class Person implements BeanNameAware {
    private Long id;
    private String name;
    /**
     * 不需要序列化
     */
    private transient String beanName;
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @PostConstruct
    public void init() {
        System.out.println(this.beanName + " : init execute");
    }
    @PreDestroy
    public void destroy() {
        System.out.println(this.beanName + " : destroy execute");
    }

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }
}

改造Person以后我们继续调用上面的方法：

我们可以得到下面的结论：
1 原型和单例模式都是会执行postconstruct
2 原型模式的生命周期不能被spring完全管理，不会执行销毁方法

如果我们需要销毁，采用下面这种方式来操作

public class BeanScopeDemo implements DisposableBean {
    @Autowired
    @Qualifier("singletonPerson")
    Person person;

    @Autowired
    @Qualifier("prototypePerson")
    Person person1;

    @Autowired
    @Qualifier("prototypePerson")
    Person person2;

    @Autowired
    Map<String, Person> personMap;
    @Autowired
    ConfigurableListableBeanFactory beanFactory;

    /**
     * 创建bean
     *
     * @return
     */
    public static Person createPerson() {
        Person person = new Person();
        person.setId(System.currentTimeMillis());
        person.setName(System.currentTimeMillis() + "");
        return person;
    }

    /**
     * 查找
     *
     * @param context
     */
    public static void scopeBeanLookUp(AnnotationConfigApplicationContext context) {
        for (int i = 0; i < 3; i++) {
            Person prototypePerson = context.getBean("prototypePerson", Person.class);
            System.out.println("prototypePerson" + prototypePerson);
            Person singletonPerson = context.getBean("singletonPerson", Person.class);
            System.out.println("singletonPerson" + singletonPerson);
        }
    }

    private static void scopedBeansByInjection(AnnotationConfigApplicationContext context) {
        BeanScopeDemo bean = context.getBean(BeanScopeDemo.class);
        System.out.println(bean.person);
        System.out.println(bean.person1);
        System.out.println(bean.person2);
        System.out.println(bean.personMap);
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(BeanScopeDemo.class);
        context.refresh();
        scopeBeanLookUp(context);
        scopedBeansByInjection(context);
        context.close();
    }

    /**
     * 默认scope 就是singleton
     *
     * @return
     */
    @Bean
    public static Person singletonPerson() {
        return createPerson();
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public static Person prototypePerson() {
        return createPerson();
    }

    @Autowired
    ConfigurableListableBeanFactory beanFactory;
    @Override
    public void destroy() throws Exception {
        this.person1.destroy();
        this.person2.destroy();
        for (Map.Entry<String, Person> entry : this.personMap.entrySet()) {
            String key = entry.getKey();
            BeanDefinition bd = beanFactory.getBeanDefinition(key);
            if (bd.isPrototype()) {
                entry.getValue().destroy();
            }

        }
    }
}

运行结果：

可以看到原型模式的对象也被销毁了。

自定义Scope

1 首先自定义Scope

public class ThreadLocalScope implements Scope {
    public static final String SCOPE_NAME = "thread_local";
    private NamedThreadLocal<Map<String, Object>> threadLocal = new NamedThreadLocal<Map<String, Object>>("thread-local-scope") {
       public Map<String, Object> initialValue() {
           return new HashMap<>();
       }
    };
    private Map<String, Object> getContext() {
        return threadLocal.get();
    }
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> context = getContext();
        Object object = context.get(name);
        if (object == null) {
            object = objectFactory.getObject();
            context.put(name, object);
        }
        return object;
    }
    @Override
    public Object remove(String name) {
        return getContext().remove(name);
    }
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        remove(name);
    }
    @Override
    public Object resolveContextualObject(String key) {
        return getContext().get(key);
    }
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }
}

2 查找方式

public class ThreadLocalScopeDemo {
    /**
     * 默认scope 就是singleton
     *
     * @return
     */
    @Bean
    @Scope(ThreadLocalScope.SCOPE_NAME)
    public static Person singletonPerson() {
        return createPerson();
    }
    /**
     * 创建bean
     *
     * @return
     */
    public static Person createPerson() {
        Person person = new Person();
        person.setId(System.currentTimeMillis());
        person.setName(System.currentTimeMillis() + "");
        return person;
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(ThreadLocalScopeDemo.class);
        // 注册工厂 也就是 ThreadLocalScope.SCOPE_NAME 这个注入会走这里
        context.addBeanFactoryPostProcessor(beanFactory -> {
            beanFactory.registerScope(ThreadLocalScope.SCOPE_NAME, new ThreadLocalScope());
        });
        context.refresh();
        scopeBeansLookUp(context);
        context.close();
    }
    private static void scopeBeansLookUp(ApplicationContext context) {
    	// 这里开启三个现场去查找
        for (int i = 0; i < 3; i ++) {
            Thread thread = new Thread(() -> {
                Person person = context.getBean( Person.class);
                System.out.println(Thread.currentThread().getId()+ " : " + person);
            });
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

结果：

也就几说我们可以减少对象的创建因为我们在Threadlocal里面存储了，所以线程内部是可以复用的，不存在线程安全问题。
比如SimpleDateFormat是非线程安全的，所以可以采用这种方式来实现。

拓展提示：SpingCloud中的@RefreshScope
参考资料：小马哥核心编程思想