GirişHer çağrıda yeni bir bean yaratır.
value Alanı
- ConfigurableBeanFactory.SCOPE_PROTOTYPE sabiti veya
- BeanDefinition.SCOPE_PROTOTYPE sabiti veya
- normal string kullanılabilir.
BeanDefinition.SCOPE_PROTOTYPE sabiti
şöyledir/**
* Scope identifier for the standard prototype scope: {@value}.
* <p>Custom scopes can be added via {@code registerScope}.
* @see #registerScope
*/
String SCOPE_PROTOTYPE = "prototype";
Aynı sonuca varmak için @Scope anotasyonu yerine @Lookup anotasyonu da
kullanılabilir.
Örnek - ConfigurableBeanFactory SabitiŞöyle
yaparız@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE,
proxyMode = ScopedProxyMode.TARGET_CLASS)
Örnek - normal string SabitiŞöyle
yaparız.
@Component
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class CompX { ....}
Scope Bean ve Singleton
Singleton bean içine Scope bean inject edilse bile singleton bean hep aynı nesneyi kullanır.
Çözüm 1
@Component
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ProductPurchasedEvent {
...
}
@Service
public class PurchaseService {
private ProductPurchasedEvent productPurchasedEvent;
@Autowired
public PurchaseService(ProductPurchasedEvent productPurchasedEvent) {
this.productPurchasedEvent = productPurchasedEvent;
}
...
}
Açıklaması
şöyle. Burada dikkat edilmesi gereken şey şu. Bu prototype bean'in herhangi bir metod çağrılınca
yeni bir nesne yaratılır. Yani iki setter() çağırırsak iki nesne yaratılır. Dolayısıyla prototype bean stateful ise tehlikeli bir yöntem
when a singleton has a prototype dependency (unless we customize it). It eagerly creates and injects all dependent objects at the application startup level
...
Spring supports proxy pattern with injecting prototype beans which means instead of injecting a real bean itself we inject a proxy object that delegates all the work to the real created beans
...
If we enable TARGET_CLASS proxy mode on our prototype class, spring creates a new instance for every method call of prototype
Çözüm 2
Her seferinde yeni bir nesne üretmek için şöyle yaparız
@Service
public class FactoryUtil implements ApplicationContextAware {
private static ApplicationContext context;
public FactoryUtil() {
}
public static <T> T getBean(Class<T> beanClass) {
return context.getBean(beanClass);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
context = applicationContext;
}
}
@Component
public class ShapeFactory {
private Map<ShapesType, Shape> myServiceCache = new HashMap<>();
private final List<Shape> handlers;
@Autowired
private ShapeFactory(List<Shape> handlers) {
this.handlers = handlers;
}
public static Shape getShapeImplementation(ShapesType shapesType) {
Shape service = myServiceCache.get(shapesType);
if (null == service) {
throw new RuntimeException("Unknown shape type: " + shapesType);
}
return FactoryUtil.getBean(service.getClass());
}
}
Scope Bean'ler İçin Pool
Örnek
Elimizde bir bean
olsun.
@Component("sheet")
@Scope(value = "prototype")
public class Sheet {
// Implementation goes here
}
Bu bean için bir havuz
oluşturalım.
public class SheetPool {
private List<Sheet> sheets;
public List<Sheet> getSheets() {
return sheets;
}
public Sheet getObject() {
int index = ThreadLocalRandom.current().nextInt(sheets.size());
return sheets.get(index);
}
}
Her çağrıda bu bean'den yeni bir tane oluşturmak için şöyle
yaparız.
@Configuration
public class ApplicationConfig {
@Autowired
ApplicationContext applicationContext;
@Bean
public SheetPool sheetPool() {
SheetPool pool = new SheetPool();
IntStream.range(0, 10).forEach(e -> {
pool.getSheets().add((Sheet) applicationContext.getBean("sheet"));
});
return pool;
}
}
