Spring中五种 Scope域

singleton，容器启动时创建（未设置延迟），容器关闭时销毁【单例】
prototype，每次使用时创建，不会自动销毁，需要调用 DefaultListableBeanFactory.destroyBean(bean) 销毁【原型】
request，每次请求用到此 bean 时创建，请求结束时销毁（每次请求来都会创建一个request域对象放到web request域当中，请求结束会被销毁）
session，每个会话用到此 bean 时创建，会话结束时销毁（会话创建时会把session对象创建出来放入web session中，会话结束时销毁，会话有默认销毁时间可以设置，长时间不访问自动销毁）
application，web 容器用到此 bean 时创建，容器停止时销毁（ServletContext创建后，首次用bean将其放入ServletContext中，销毁Spring未实现）

单例Bean注入其他Scope Bean不做处理，会出现Scope生效的情况，需要在注入bean对象上添加@Lazy注解

演示：

不同scope域的bean

@Scope("application")
@Component
public class BeanForApplication {
    private static final Logger log = LoggerFactory.getLogger(BeanForApplication.class);

    @PreDestroy
    public void destroy() {
        log.debug("destroy");
    }
}

@Scope("session")
@Component
public class BeanForSession {
    private static final Logger log = LoggerFactory.getLogger(BeanForSession.class);

    @PreDestroy
    public void destroy() {
        log.debug("destroy");
    }
}

@Scope("request")
@Component
public class BeanForRequest {
    private static final Logger log = LoggerFactory.getLogger(BeanForRequest.class);

    @PreDestroy
    public void destroy() {
        log.debug("destroy");
    }

}

@RestController
public class MyController {
    
    @Lazy
    @Autowired
    private BeanForRequest beanForRequest;

    @Lazy
    @Autowired
    private BeanForSession beanForSession;

    @Lazy
    @Autowired
    private BeanForApplication beanForApplication;

    @GetMapping(value = "/test", produces = "text/html")
    public String test(HttpServletRequest request, HttpSession session) {
        ServletContext sc = request.getServletContext();
        String sb = "<ul>" +
                    "<li>" + "request scope:" + beanForRequest + "</li>" +
                    "<li>" + "session scope:" + beanForSession + "</li>" +
                    "<li>" + "application scope:" + beanForApplication + "</li>" +
                    "</ul>";
        return sb;
    }
}

分析 - singleton 注入其它 scope 失效

以单例注入多例为例

有一个单例对象 E

@Component
public class E {
    @Autowired
    private F1 f1;

    public F1 getF1() {
        return f1;
    }
}

要注入的对象 F1 期望是多例

@Component
@Scope("prototype")
public class F1 {
    private static final Logger log = LoggerFactory.getLogger(F.class);

    public F1() {
        log.info("F1()");
    }
}

测试：

   E e = context.getBean(E.class);
   log.debug("{}", e.getF1());
   log.debug("{}", e.getF1());

输出：

com.lkl.spring.chapter8.sub.F1@72d1ad2e
com.lkl.spring.chapter8.sub.F1@72d1ad2e

发现它们是同一个对象，而不是期望的多例对象

对于单例对象来讲，依赖注入仅发生了一次，后续再没有用到多例的 F1，因此 E 用的始终是第一次依赖注入的 F

解决

仍然使用 @Lazy 生成代理
代理对象虽然还是同一个，但当每次使用代理对象的任意方法时，由代理创建新的 f 对象

@Component
public class E {

    @Autowired
    @Lazy
    public void setF(F f) {
        this.f = f;
        log.info("setF(F f) {}", f.getClass());
    }

    // ...
}

注意

@Lazy 也可以加在成员变量上，但加在 set 方法上的目的是可以观察输出，加在成员变量上就不行了
@Autowired 加在 set 方法的目的类似

        E e = context.getBean(E.class);
        log.debug("{}", e.getF1().getClass());
        log.debug("{}", e.getF1());
        log.debug("{}", e.getF1());

输出：

class com.lkl.spring.chapter8.sub.F1$$EnhancerBySpringCGLIB$$278636ac
com.lkl.spring.chapter8.sub.F1@9597028
com.lkl.spring.chapter8.sub.F1@4efbca5a

f 对象的类型是代理类型

解决方法

单例注入其它 scope 的四种解决方法
- @Lazy
- @Scope(value = “prototype”, proxyMode = ScopedProxyMode.TARGET_CLASS)
- ObjectFactory
- ApplicationContext
解决方法虽然不同，但理念上殊途同归: 都是推迟其它 scope bean 的获取

@Component
public class E {

    // 方法一
    @Lazy
    @Autowired
    private F1 f1;

    // 方法二
    @Autowired
    private F2 f2;

    // 方法三
    @Autowired
    private ObjectFactory<F3> f3;

    // 方法四
    @Autowired
    private ApplicationContext context;

    public F1 getF1() {
        return f1;
    }

    public F2 getF2() {
        return f2;
    }

    public F3 getF3() {
        return f3.getObject();
    }

    public F4 getF4() {
        return context.getBean(F4.class);
    }
}