स्प्रिंग जावा कॉन्फ़िगरेशन

Question

का उपयोग कर सिंगलटन बीन में प्रोटोटाइप ऑब्जेक्ट्स कैसे उत्पन्न करें, यहां मेरे पास अभी ठीक है जो ठीक काम करता है।

मैं वर्ग बाजार

class market { 

    public ArrayList<Items> createItems(HashMap<String,String> map) { 
     ArrayList<Items> array = new ArrayList<Items>(); 
     for (Map.Entry<String, String> m : map.entrySet()) { 
      Item item = new Item(); 
      item.setName(m.key()); 
      item.setValue(m.value()); 
      array.add(item); 
     } 
     return array; 
    } 
} 

वर्ग मद है गेटर और नाम और मूल्य के लिए सेटर के साथ साधारण क्लास

यहाँ है कैसे: सभी यह होता है एक बाजार वर्ग जो रिटर्न आइटम की एक सरणी वस्तुओं है मेरी कॉन्फ़िग फ़ाइल दिखता है:

@Configuration 
public class MarketConfig { 

    @Bean 
    public Market market() { 
     return new Market(); 
    } 
} 

मैं अपने कोड में परिवर्तन करना चाहते :(कारण: मुझे नहीं चाहते

Item item = new Item(); 

तब विधि में। मैं वसंत बाजार को इसकी सुई देने)

class market { 

    public Item item; 
    //getters and setters for item 

    public ArrayList<Items> createItems(HashMap<String,String> map) { 
     ArrayList<Items> array = new ArrayList<Items>(); 
     for (Map.Entry<String, String> m : map.entrySet()) { 
      item.setName(m.key()); 
      item.setValue(m.value()); 
      array.add(item); 
     } 
     return array; 
    } 
} 

@Configuration 
public class MarketConfig { 

    @Bean 
    @Scope("prototype") 
    public Item item() { 
     return new Item(); 
    } 

    @Bean 
    public Market market() { 
     Market bean = new Market(); 
     bean.setItem(item()); 
    } 
} 

मुझे पता है कि प्रोटोटाइप गुंजाइश मुझे नए सेम हर बार मैं आइटम फोन() दे देंगे चाहते हैं; अब मैं createItems विधि के लूप के लिए प्रत्येक पुनरावृत्ति के लिए नया बीन चाहता हूं। मैं मुझे देने के लिए वसंत कैसे बता सकता हूँ।

एक तरह से मुझे पता है

applicationContext context = new AnnotationConfigApplicationContext(); 
context.getBean(Item.class); 

करते है लेकिन क्या कोई अन्य मेरे काम किया जाना तरीका है। धन्यवाद

Answer 1

हाँ, आप का उपयोग कर लुक-अप विधि

public abstract class ItemFactory { 

    public abstract Item createItem(); 

} 

अब

applicationContext.xml में सिर्फ निम्नलिखित डाल मांग पर प्रोटोटाइप विधि बना सकते हैं:

<bean id="item" class="x.y.z.Item" scope="prototype" lazy-init="true"/> 

और कारखाने कॉन्फ़िगर करें:

<bean id="itemFactory" class="x.y.z.ItemFactory"> 
<lookup-method name="createItem" bean="item"/> 
</bean> 

अब इसे उपयोग करने के लिए आपको बस इतना करना है कि वह स्वतः है किसी भी सेम के अंदर यह गुस्सा:

और yout देखो-अप विधि कॉल:

@Service 
public class MyService{ 

    @Autowired 
    ItemFactory itemFactory; 

    public someMethod(){ 
     Item item = itemFactrory.createItem(); 
    } 

} 

हर बार जब आप फोन createItem() आप आइटम वर्ग के नव निर्मित उदाहरण के संदर्भ में प्राप्त होगा।

पी.एस: मुझे लगता है कि आप उपयोग कर रहे एक्सएमएल आप की जाँच करता है, तो लुक-अप विधि विन्यास सेम अंदर विन्यस्त किया जा सकता की जरूरत के बजाय @Configuration।

उम्मीद है कि यह मदद करता है।

अद्यतन: चाल सरल है:

@Configuration 
public class BeanConfig { 

    @Bean 
    @Scope(value="prototype") 
    public Item item(){ 
     return new Item(); 
    } 


    @Bean 
    public ItemManager itemManager(){ 
     return new ItemManager() { 

      @Override 
      public Item createItem() { 
       return item(); 
      } 
     }; 
    } 
} 

Answer 2

यदि आप जावा 8

@Configuration 
public class Config { 

    @Bean 
    @Scope(value = "prototype") 
    public Item item() { 
     return new Item(); 
    } 

    @Bean 
    public Supplier<Item> itemSupplier() { 
     return this::item; 
    } 
} 

उपयोग कर रहे हैं सरल किया जा सकता और उसके बाद आप करने के लिए अपने बाजार कक्षा में इस आपूर्तिकर्ता उपयोग कर सकते हैं प्रोटोटाइप आइटम सेम बनाओ।

@Component 
public class Market { 

    private final Supplier<Item> itemSupplier; 

    @Autowired 
    public Market(Supplier<Item> itemSupplier) { 
     this.itemSupplier = itemSupplier; 
    } 

    private Item createItem() { 
     return itemSupplier.get(); 
    } 

} 

काफी सरल और अतिरिक्त फैक्ट्री सेम या इंटरफेस में कोई आवश्यकता नहीं है।