4.Bean的Scope作用域用法

谁借莪１个温暖的怀抱￠ 2021-09-20 14:36 350阅读 0赞

### 基本的作用域 ###

在面向对象程序设计中一般指对象或变量之间的可见范围。而在Spring容器中是指其创建的Bean对象相对于其他Bean对象的请求可见范围。Spring提供“singleton”和“prototype”两种基本作用域，另外提供“request”、“session”、“global"、”session”三种web作用域；Spring还允许用户定制自己的作用域。

一、singleton：使用BeanFactory或ApplicationContext取得的实例默认为Singleton，“singleton”作用域的Bean只会在每个Spring IoC容器中存在一个实例，而且其完整生命周期完全由Spring容器管理。对于单线程的程序没有问题，如果是多线程的程序就要考虑线程安全的问题。对于所有获取该Bean的操作Spring容器将只返回同一个Bean。

1）通过在类上定义静态属性保持该实例：一般指一个Java虚拟机 ClassLoader装载的类只有一个实例，一般通过类静态属性保持该实例，这样就造成需要单例的类都需要按照单例设计模式进行编码；Spring没采用这种方式，因为该方式属于侵入式设计。

2） 通过注册表方式： 首先将需要单例的实例通过唯一键注册到注册表，然后通过键来获取单例，写个例子来说明，注意本注册表实现了Spring接口“SingletonBeanRegistry”，该接口定义了操作共享的单例对象，Spring容器实现将实现此接口；所以共享单例对象通过“registerSingleton”方法注册，通过“getSingleton”方法获取，消除了编程方式单例，注意在实现中不考虑并发：

public class SingletonBeanRegister implements SingletonBeanRegistry {    
        //单例Bean缓存池，此处不考虑并发
        private final Map<String, Object> BEANS = new HashMap<String, Object>();
        @Override
        public boolean containsSingleton(String beanName) {
            return BEANS.containsKey(beanName);
        }
        @Override
        public Object getSingleton(String beanName) {
            return BEANS.get(beanName);
        }
        @Override
        public int getSingletonCount() {
            return BEANS.size();
        }
        @Override
        public Object getSingletonMutex() {
            return null;
        }
        @Override
        public String[] getSingletonNames() {
            return BEANS.keySet().toArray(new String[0]);
        }
        @Override
        public void registerSingleton(String beanName, Object bean) {
            if(BEANS.containsKey(beanName)) {
                throw new RuntimeException("[" + beanName + "] 已存在");
            }
            BEANS.put(beanName, bean);
        }   
    }

Spring是注册表单例设计模式的实现，消除了编程式单例，而且对代码是非入侵式，在Spring容器中如果没指定作用域默认就是“singleton”，配置方式通过scope属性配置。

二、prototype：即原型，指每次向Spring容器请求获取Bean都返回一个全新的Bean，通过将scope设置为"prototype",可以每次创建Bean时都获得一个新的实例。相对于“singleton”来说就是不缓存Bean，每次都是一个全新Bean。

Spring中的原型和GoF中介绍的原型含义是不一样的：

GoF通过用原型实例指定创建对象的种类，而Spring容器用Bean定义指定创建对象的种类；

GoF通过拷贝这些原型创建新的对象，而Spring容器根据Bean定义创建新对象。

其相同地方都是根据某些东西创建新东西，而且GoF原型必须显示实现克隆操作，属于侵入式，而Spring容器只需配置即可，属于非侵入式。

接下来我们看下Spring如何实现原型

1）首先让我们来定义Bean“原型”：Bean定义，所有对象将根据Bean定义创建；在此我们只是简单示例一下，不会涉及依赖注入等复杂实现：BeanDefinition类定义属性“class”表示原型类，“id”表示唯一标识，“scope”表示作用域，具体如下：

public class BeanDefinition {    
        //单例
        public static final int SCOPE_SINGLETON = 0; 
        //原型
        public static final int SCOPE_PROTOTYPE = 1;    
        //唯一标识
        private String id;
        //class全限定名
        private String clazz;
        //作用域
        private int scope = SCOPE_SINGLETON;       
      ...省略setter和getter方法；
    }

2）接下来让我们看看Bean定义注册表，类似于单例注册表：

public class BeanDifinitionRegister {   
        //bean定义缓存，此处不考虑并发问题
        private final Map<String, BeanDefinition> DEFINITIONS = new HashMap<String, BeanDefinition>();
        //注册Bean定义
        public void registerBeanDefinition(String beanName, BeanDefinition bd) {
            //1.本实现不允许覆盖Bean定义
            if(DEFINITIONS.containsKey(bd.getId())) {
                throw new RuntimeException("已存在Bean定义，此实现不允许覆盖");
            }
            //2.将Bean定义放入Bean定义缓存池
            DEFINITIONS.put(bd.getId(), bd);
        }
        //获取Bean定义
        public BeanDefinition getBeanDefinition(String beanName) {
            return DEFINITIONS.get(beanName);
        }
        //是否包含Bean定义
        public boolean containsBeanDefinition(String beanName) {
            return DEFINITIONS.containsKey(beanName);
        }        
    }

3）接下来应该来定义BeanFactory了：

public class DefaultBeanFactory {
       
        //Bean定义注册表
        private BeanDifinitionRegister DEFINITIONS = new BeanDifinitionRegister();
        
        //单例注册表
        private final SingletonBeanRegistry SINGLETONS = new SingletonBeanRegister();
        
        public Object getBean(String beanName) {
            //1.验证Bean定义是否存在
            if(!DEFINITIONS.containsBeanDefinition(beanName)) {
                throw new RuntimeException("不存在[" + beanName + "]Bean定义");
            }
            //2.获取Bean定义
            BeanDefinition bd = DEFINITIONS.getBeanDefinition(beanName);
            //3.是否该Bean定义是单例作用域
            if(bd.getScope() == BeanDefinition.SCOPE_SINGLETON) {
                //3.1 如果单例注册表包含Bean，则直接返回该Bean
                if(SINGLETONS.containsSingleton(beanName)) {
                    return SINGLETONS.getSingleton(beanName);
                }
                //3.2单例注册表不包含该Bean，
                //则创建并注册到单例注册表，从而缓存
                SINGLETONS.registerSingleton(beanName, createBean(bd));
                return SINGLETONS.getSingleton(beanName);
            }
            //4.如果是原型Bean定义,则直接返回根据Bean定义创建的新Bean，每次都是新的，无缓存
            if(bd.getScope() == BeanDefinition.SCOPE_PROTOTYPE) {
                return createBean(bd);
            }
            //5.其他情况错误的Bean定义
            throw new RuntimeException("错误的Bean定义");
        }
        
       
        public void registerBeanDefinition(BeanDefinition bd) {
            DEFINITIONS.registerBeanDefinition(bd.getId(), bd);
        }
        
        private Object createBean(BeanDefinition bd) {
            //根据Bean定义创建Bean
            try {
                Class clazz = Class.forName(bd.getClazz());
                //通过反射使用无参数构造器创建Bean
                return clazz.getConstructor().newInstance();
            } catch (ClassNotFoundException e) {
                throw new RuntimeException("没有找到Bean[" + bd.getId() + "]类");
            } catch (Exception e) {
                throw new RuntimeException("创建Bean[" + bd.getId() + "]失败");
            }
        }
    }

其中方法getBean用于获取根据beanName对于的Bean定义创建的对象，有单例和原型两类Bean；

registerBeanDefinition方法用于注册Bean定义，私有方法createBean用于根据Bean定义中的类型信息创建Bean。

3）测试一下吧，在此我们只测试原型作用域Bean，对于每次从Bean工厂中获取的Bean都是一个全新的对象，代码片段（BeanFatoryTest）如下：

public class BeanFatoryTest {
        
        @Test
        public void testPrototype() throws Exception {
            //1.创建Bean工厂
            DefaultBeanFactory bf = new DefaultBeanFactory();
            //2.创建原型 Bean定义
            BeanDefinition bd = new BeanDefinition();
            bd.setId("bean");
            bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
            bd.setClazz(HelloImpl2.class.getName());
            bf.registerBeanDefinition(bd);
            //对于原型Bean每次应该返回一个全新的Bean
            System.out.println(bf.getBean("bean") != bf.getBean("bean"));
        }
    
        @Test
        public void testSingleton() throws Exception {
            //1.创建Bean工厂
            DefaultBeanFactory bf = new DefaultBeanFactory();
            //2.创建单例 Bean定义
            BeanDefinition bd = new BeanDefinition();
            bd.setId("bean");
            bd.setScope(BeanDefinition.SCOPE_SINGLETON);
            bd.setClazz(HelloImpl2.class.getName());
            bf.registerBeanDefinition(bd);
            //对于单例Bean应该返回同一个Bean
            System.out.println(bf.getBean("bean") == bf.getBean("bean"));
        }
    }

### 销毁Bean ###

一旦将基于 spring的(web)应用停止, Spring框架将调用那些 JavaBean实例中存在的生命周期方法,或者那些在 Spring配置文件中指定了 destroy\_method属性的 JavaBean。最终, Spring将销毁 JavaBean实例。请注意, 这些内容只适合于那些通过“ singleton”方式创建的 JavaBean 实例 。 对于那些以prototype”方式创建的 JavaBean实例, Spring并不能够控制其生命周期, 因为一旦这种JavaBean实例创建成功,整个 JavaBean将交付给 Spring应用去管理。

### 抽象 Bean和子 Bean定义 ###

对于包含大量配置信息的<bean>元素而言, 其带来的管理复杂性给开发者也带来了很多不便。比如,有些<bean>元素包括初始方法、静态工厂方法、构建器参数、是否单实例以及属性值等内容。因此,如果能够将这些信息类似于 00一样,通过继承解决这种问题那么将是多么好的事情啊。 Spring通过定义抽象 Bean和子 Bean能够简化对<bean>的管理,从而提高开发者的开发效率。

下面通过一个简单的例子说明一下，例如

public class Some {
        private String message;
        private String name;
        public void setMessage(String message) {
            this.message = message;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public String getMessage() {
            return message;
        }
    }

假如会有很多Some 的子类，那么我们可以这样定义：

在"parentBean"中设置了abstract="true"，表示这是个抽象的bean定义，Spring不会去尝试实例化，而在"subBean"中设置了parent="parentBean"，表示他将继承"parentBean"的设置，只有"name"属性会被重新定义，写个例子测试下

public class App {
        public static void main(String[] args) {
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("beans1.xml");
    
            Some some = (Some) context.getBean("subBean");
            System.out.println(some.getMessage());
            System.out.println(some.getName());
        }
    }