文章目录

Spring Bean

作用域

singleton
prototype
request
session

作用域代理
懒加载
生命周期

初始化
销毁
配置全局默认初始化、销毁方法

Bean 前置、后置处理器
参考

Spring Bean

作用域

singleton：一个 Bean 容器中只存在一个实例（Spring 默认作用域）
prototype：每次注入或者通过 Spring 应用上下文获取时都会创建一个单独的实例
request：每个 request 请求都会创建一个单独的实例
session：每个 session 都会创建一个单独的实例
application：每个 servletContext 都会创建一个单独的实例
websocket：每个 websocket 都会创建一个单独的实例
simpleThreadScope：每个线程都会创建一个单独的实例

singleton

使用 @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON) 注解标注 Bean 的作用域为 singleton ，则每次注入的 bean 都是同一个实例。

JavaConfig

@Configuration
public class ScopeBeanConfig {

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
    public SingletonBean singletonBean() {
        return new SingletonBean();
    }
}

public class SingletonBean {
}

XML 配置

    <bean class="SingletonBean" scope="singleton"/>

prototype

使用 @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) 注解标注 Bean 的作用域为 prototype ，则每次注入或从 Spring 应用上下文获取的 bean 都会创建一个新的实例。

JavaConfig

@Configuration
public class ScopeBeanConfig {

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public PrototypeBean prototypeBean() {
        return new PrototypeBean();
    }
}

public class PrototypeBean {
}

XML 配置

    <bean class="PrototypeBean" scope="prototype"/>

request

使用 @RequestScope 注解标注 Bean 的作用域为 request ，则每次 request 请求的 bean 都会创建一个新的实例。

JavaConfig

@Configuration
public class ScopeBeanConfig {

    @Bean
    @RequestScope
    public RequestBean requestBean() {
        return new RequestBean();
    }
}

public class RequestBean {
}

XML 配置

    <bean class="RequestBean" scope="request"/>

session

使用 @SessionScope 注解标注 Bean 的作用域为 session ，则会为每个 session 创建一个新的 bean 实例。

JavaConfig

@Configuration
public class ScopeBeanConfig {

    @Bean
    @SessionScope
    public SessionBean sessionBean() {
        return new SessionBean();
    }
}

public class SessionBean {
}

XML 配置

    <bean class="SessionBean" scope="session"/>

作用域代理

当 request/session 作用域的 bean(cart) 注入到 singleton 作用域的 bean(storeService) 时


@Configuration
public class ScopeBeanConfig {

    @Bean
    @SessionScope(proxyMode = ScopedProxyMode.INTERFACES)
    public Cart cart(){
        return new ShoppingCart();
    }

    @Bean
    public StoreService storeService(){
        return new StoreServiceImpl();
    }
}

public interface Cart {
}

public class ShoppingCart implements Cart {
}

public interface StoreService {
    void add();
}

public class StoreServiceImpl implements StoreService {

    @Autowired
    private Cart cart;

    @Override
    public void add() {
        System.out.println(cart.toString());
    }
}

singleton 作用域的 StoreService 在 Spring 应用上下文加载时实例化，同时试图将 Cart 构造注入。但是 session 作用域的 Cart 直到创建会话 session 后才会实例化。因此，Spring 会注入一个 Cart 的代理（暴露 Cart 中定义的方法），当 StoreService 调用 Cart 的方法时，代理会对其进行懒解析并调用委托给 session 作用域内真正的 Cart 。

通过 proxyMode 属性指定代理方式：

ScopedProxyMode.INTERFACES：基于 JDK 动态接口代理
ScopedProxyMode.TARGET_CLASS ：基于 CGLib 代理

懒加载

Spring 容器会在创建容器时提前初始化 singleton 作用域的 Bean。但是如果 Bean 被标注了 lazy-init="true" ，则该 Bean 只有在其被需要的时候才会被初始化。

懒加载只对 singleton 作用域的 Bean 有效。
优点：节省资源
缺点：导致操作的响应时间增加

生命周期

初始化

如果需要在 Bean 实例化之后执行逻辑：

使用 init-method

public class Bean {
  public void init() {
    // To do
  }
}

通过 XML 配置

<bean class="Bean" init-method="init"/>

通过 JavaConfig

    @Bean(initMethod = "init")
    public Bean bean() {
        return new Bean();
    }

让 Bean 实现 org.springframework.beans.factory. InitializingBean 接口，覆盖 afterPropertiesSet 方法

public class Bean implements InitializingBean {
  @Override
  public void afterPropertiesSet() throws Exception {
    // To do
  }
}

销毁

如果需要在 Bean 销毁之前执行逻辑：

使用 destroy-method

public class Bean {

  public void destroy() {
    //To do
  }
}