Spring中如何自定义Scope（sping bean生命周期理解）

一、Scope 的作用

        Scope 用于声明容器中的对象应该处的限定场景或者说该对象的存活时间。Scope决定了Spring IoC容器中Bean的生命周期和可见性。

1. 管理Bean的生命周期：Scope定义了Bean的创建、存在以及销毁的边界。不同的Scope会有不同的生命周期策略。
2. 控制Bean的可见性和共享性：通过Scope可以控制Bean在容器中的可见范围以及是否可以被多个请求或会话共享。
3. 优化资源利用：通过合理使用不同Scope，可以避免创建过多的Bean实例，从而优化内存使用和应用性能。

二、Spring 提供的Scope

1. singleton：这是Spring的默认Scope。在Spring IoC容器中，对于声明为singleton的Bean，只会存在一个共享的Bean实例。所有对该Bean的请求都会返回这个唯一实例。这种Scope适用于无状态的Bean，如服务类、工具类等。

2. prototype：对于声明为prototype的Bean，每次对该Bean的请求都会创建一个新的实例。这种Scope适用于有状态的Bean，如用户会话信息、HTTP请求参数等。需要注意的是，Spring容器不会管理prototype Scope的Bean的生命周期，销毁这些Bean的责任由客户端代码承担。

3. request：这种Scope只能在Web应用中使用。对于声明为request的Bean，每次HTTP请求都会创建一个新的Bean实例，并且这个实例仅在当前请求内有效。这种Scope适用于与请求相关的数据，如请求参数、请求头等。

4. session：同样只能在Web应用中使用。对于声明为session的Bean，每个HTTP会话都会创建一个新的Bean实例，并且这个实例在当前会话内有效。这种Scope适用于与用户会话相关的数据，如用户登录信息、购物车数据等。

5. global session（或application scope在某些上下文中）：这种Scope主要用于基于Portlet的Web应用中，类似于标准的HTTP Session Scope，但在非Portlet环境中，它通常会被视为session Scope。在Portlet应用中，global session Scope的Bean会在整个Portlet应用中共享。

注意：

• 在使用request、session、global session等Web相关的Scope时，需要在web.xml中配置相应的ContextListener或Filter，以确保Spring能够正确地管理这些Scope的Bean。
• Scope的选择应根据Bean的用途和应用的需求来决定，避免不必要的资源消耗和性能问题。

三、自定义Scope

        spring允许开发者通过实现Scope接口来创建自定义的Scope。这为开发者提供了极大的灵活性，可以根据应用的特定需求来定义Bean的生命周期和可见性。

3.1 实现 Scope 接口

import org.springframework.beans.factory.ObjectFactory;  
import org.springframework.beans.factory.config.Scope;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.Map;  
  
public class MyCustomScope implements Scope {  
  
    public static final String SCOPE_NAME = "myCustomScope";

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        System.out.println("BeanMyScope--------------> objectFactory.get: " + name);

        // 每次使用，创建一个新bean
        return objectFactory.getObject();
    }

  
    @Override  
    public Object remove(String name) {  
        return this.scopedObjects.remove(name);  
    }  
  
    @Override  
    public void registerDestructionCallback(String name, Runnable callback) {  
        // 在这个简单的例子中，我们不处理销毁回调  
        // 在实际使用中，你可能需要维护一个回调列表，并在适当的时机调用它们  
    }  
  
    @Override  
    public Object resolveContextualObject(String key) {  
        // 在这个例子中，我们不解析上下文对象  
        // 如果有需要，可以根据 key 解析并返回上下文相关的对象  
        return null;  
    }  
  
    @Override  
    public String getConversationId() {  
        // 对于这个作用域，我们不需要会话或请求ID  
        // 如果需要，则返回适当的ID（如线程ID、请求ID等）  
        return null;  
    }  
}

2. 自定义注解

import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Scope(MyCustomScope.SCOPE_NAME) // 使用自定义作用域的名称
public @interface MyScope {
    /**
     * 定义代理模式，默认为 TARGET_CLASS
     * @return ScopedProxyMode
     */
    ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;
}

3. 注册

import org.springframework.beans.factory.config.CustomScopeConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ScopeConfig {
    @Bean
    public CustomScopeConfigurer customScopeConfigurer() {
        CustomScopeConfigurer configurer = new CustomScopeConfigurer();
        configurer.addScope(MyCustomScope.SCOPE_NAME, new MyCustomScope());
        return configurer;
    }
}

3. 使用

@Component
@Data
@MyScope  // 直接使用自定义的scope注解
public class User {

    private String name;

    public User() {
        this.name = UUID.randomUUID().toString();
        System.out.println("User construction -------->");
    }

}

4. 使用测试

1.  未使用bean时，不会实际创建对象，实际为代理对象（为懒加载方式）

2.  每次使用bean时，都会从我们的scope实现类的get方法冲获取对象（MyCustomScope.get）， 而我们的scope对象每次都是新建一个新的对象（objectFactory.getObject）因此每次使用bean都是一个新创建的对象

@RestController
public class StartController extends BaseController { 
   
    @GetMapping("test")
    private String test() {
        User user = ApplicationContextUtils.getBean(User.class);

        // 未使用user时，不会实际创建对象，
        // 因此此处输出的时代理对象: xx.xx.User$$EnhancerBySpringCGLIB$$3e5e10d9
        System.out.println("---------> " + user.getClass());

        // 每次使用user对象时，都会从我们的scope对象的get方法冲获取对象（MyCustomScope.get）
        // 而我们的scope对象每次都是新建一个新的对象（objectFactory.getObject）
        // 因此，下面每次使用的user都是一个新建的user对象
        System.out.println("use 1 ---------> " + user.getName());
        System.out.println("use 2 ---------> " + user.getName());
        System.out.println("use 3 ---------> " + user.getName());
        return "--> " + user.getName();
    }


}

四、总结

        理解spring 中scope 对我们使用spring bean生成加载过程、生命周期非常有用。如果疑问随时留言沟通！