springBean的作用域怎么实现

发布时间：2023-02-07 09:22:05 作者：iii
来源：亿速云阅读：152

Spring Bean的作用域怎么实现

在Spring框架中，Bean的作用域（Scope）决定了Bean的生命周期和可见性。Spring提供了多种作用域选项，开发者可以根据需求选择合适的作用域来管理Bean的创建和销毁。本文将详细介绍Spring Bean的作用域类型、实现方式以及如何在实际开发中使用这些作用域。

1. Spring Bean的作用域类型

Spring框架支持以下几种Bean的作用域：

Singleton（单例）：默认作用域，Spring容器中只会存在一个Bean实例，所有对该Bean的请求都会返回同一个实例。
Prototype（原型）：每次请求Bean时，Spring容器都会创建一个新的Bean实例。
Request（请求）：每个HTTP请求都会创建一个新的Bean实例，仅适用于Web应用。
Session（会话）：每个HTTP会话都会创建一个新的Bean实例，仅适用于Web应用。
Application（应用）：每个ServletContext生命周期内创建一个Bean实例，仅适用于Web应用。
WebSocket（WebSocket）：每个WebSocket会话内创建一个Bean实例，仅适用于Web应用。

2. 如何配置Bean的作用域

在Spring中，可以通过XML配置、注解配置或Java配置来指定Bean的作用域。

2.1 XML配置

在XML配置文件中，可以使用<bean>标签的scope属性来指定Bean的作用域。

<bean id="singletonBean" class="com.example.SingletonBean" scope="singleton"/>
<bean id="prototypeBean" class="com.example.PrototypeBean" scope="prototype"/>
<bean id="requestBean" class="com.example.RequestBean" scope="request"/>
<bean id="sessionBean" class="com.example.SessionBean" scope="session"/>
<bean id="applicationBean" class="com.example.ApplicationBean" scope="application"/>
<bean id="websocketBean" class="com.example.WebSocketBean" scope="websocket"/>

2.2 注解配置

在基于注解的配置中，可以使用@Scope注解来指定Bean的作用域。

@Component
@Scope("singleton")
public class SingletonBean {
    // Bean implementation
}

@Component
@Scope("prototype")
public class PrototypeBean {
    // Bean implementation
}

@Component
@Scope("request")
public class RequestBean {
    // Bean implementation
}

@Component
@Scope("session")
public class SessionBean {
    // Bean implementation
}

@Component
@Scope("application")
public class ApplicationBean {
    // Bean implementation
}

@Component
@Scope("websocket")
public class WebSocketBean {
    // Bean implementation
}

2.3 Java配置

在基于Java的配置中，可以使用@Bean注解结合@Scope注解来指定Bean的作用域。

@Configuration
public class AppConfig {

    @Bean
    @Scope("singleton")
    public SingletonBean singletonBean() {
        return new SingletonBean();
    }

    @Bean
    @Scope("prototype")
    public PrototypeBean prototypeBean() {
        return new PrototypeBean();
    }

    @Bean
    @Scope("request")
    public RequestBean requestBean() {
        return new RequestBean();
    }

    @Bean
    @Scope("session")
    public SessionBean sessionBean() {
        return new SessionBean();
    }

    @Bean
    @Scope("application")
    public ApplicationBean applicationBean() {
        return new ApplicationBean();
    }

    @Bean
    @Scope("websocket")
    public WebSocketBean webSocketBean() {
        return new WebSocketBean();
    }
}

3. 作用域的实现原理

Spring通过Scope接口及其实现类来管理不同作用域的Bean。Scope接口定义了获取和销毁Bean实例的方法，Spring容器在创建和管理Bean时会调用这些方法。

3.1 Singleton作用域

Singleton作用域是Spring默认的作用域。Spring容器在启动时会创建Singleton Bean的实例，并将其存储在容器中。每次请求该Bean时，Spring容器都会返回同一个实例。

public class SingletonBean {
    private static final SingletonBean INSTANCE = new SingletonBean();

    private SingletonBean() {}

    public static SingletonBean getInstance() {
        return INSTANCE;
    }
}

在Spring中，Singleton Bean的实例由DefaultSingletonBeanRegistry类管理，该类维护了一个singletonObjects的Map，用于存储Singleton Bean的实例。

3.2 Prototype作用域

Prototype作用域的Bean每次请求时都会创建一个新的实例。Spring容器不会缓存Prototype Bean的实例，每次请求时都会调用Bean的构造函数来创建新的实例。

public class PrototypeBean {
    private static int instanceCount = 0;

    public PrototypeBean() {
        instanceCount++;
        System.out.println("PrototypeBean instance created: " + instanceCount);
    }
}

在Spring中，Prototype Bean的实例由AbstractBeanFactory类管理，该类在每次请求Prototype Bean时都会调用createBean方法来创建新的实例。

3.3 Request作用域

Request作用域的Bean在每个HTTP请求中都会创建一个新的实例。Spring通过RequestScope类来实现Request作用域的管理。

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestBean {
    private String requestId;

    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }
}

在Spring中，Request Bean的实例由RequestScope类管理，该类在每次HTTP请求时都会创建一个新的Bean实例，并将其存储在HttpServletRequest的属性中。

3.4 Session作用域

Session作用域的Bean在每个HTTP会话中都会创建一个新的实例。Spring通过SessionScope类来实现Session作用域的管理。

@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionBean {
    private String sessionId;

    public String getSessionId() {
        return sessionId;
    }

    public void setSessionId(String sessionId) {
        this.sessionId = sessionId;
    }
}

在Spring中，Session Bean的实例由SessionScope类管理，该类在每次HTTP会话时都会创建一个新的Bean实例，并将其存储在HttpSession的属性中。

3.5 Application作用域

Application作用域的Bean在每个ServletContext生命周期内都会创建一个新的实例。Spring通过ServletContextScope类来实现Application作用域的管理。

@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ApplicationBean {
    private String applicationId;

    public String getApplicationId() {
        return applicationId;
    }

    public void setApplicationId(String applicationId) {
        this.applicationId = applicationId;
    }
}

在Spring中，Application Bean的实例由ServletContextScope类管理，该类在ServletContext初始化时创建一个新的Bean实例，并将其存储在ServletContext的属性中。

3.6 WebSocket作用域

WebSocket作用域的Bean在每个WebSocket会话中都会创建一个新的实例。Spring通过WebSocketScope类来实现WebSocket作用域的管理。

@Component
@Scope(value = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class WebSocketBean {
    private String webSocketId;

    public String getWebSocketId() {
        return webSocketId;
    }

    public void setWebSocketId(String webSocketId) {
        this.webSocketId = webSocketId;
    }
}

在Spring中，WebSocket Bean的实例由WebSocketScope类管理，该类在每次WebSocket会话时都会创建一个新的Bean实例，并将其存储在WebSocket会话的属性中。

4. 作用域的代理模式

在某些情况下，Spring需要为Bean创建代理对象，以便在Bean的作用域范围内正确地管理Bean的生命周期。Spring提供了两种代理模式：ScopedProxyMode.TARGET_CLASS和ScopedProxyMode.INTERFACES。

4.1 ScopedProxyMode.TARGET_CLASS

ScopedProxyMode.TARGET_CLASS使用CGLIB库为目标类创建代理对象。这种代理模式适用于没有实现接口的类。

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestBean {
    // Bean implementation
}

4.2 ScopedProxyMode.INTERFACES

ScopedProxyMode.INTERFACES使用JDK动态代理为目标接口创建代理对象。这种代理模式适用于实现了接口的类。

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.INTERFACES)
public class RequestBean implements RequestBeanInterface {
    // Bean implementation
}

5. 总结

Spring Bean的作用域是Spring框架中非常重要的概念，它决定了Bean的生命周期和可见性。通过合理选择和使用不同的作用域，开发者可以更好地管理Bean的创建和销毁，从而提高应用程序的性能和可维护性。本文详细介绍了Spring Bean的作用域类型、配置方式、实现原理以及代理模式，希望能够帮助读者更好地理解和应用Spring Bean的作用域。