स्प्रिंग बीन कस्टम स्कोप

मैं एक उदाहरण देने की कोशिश करूंगा जब स्प्रिंग कस्टम स्कोप की आवश्यकता होगी।



हम एक बी 2 बी और एसएएएस कंपनी हैं, और हमारे प्रत्येक क्लाइंट के लिए कुछ लंबी प्रक्रियाएं टाइमर पर चलती हैं।

प्रत्येक क्लाइंट के पास कुछ गुण (नाम, सदस्यता का प्रकार, आदि) हैं।

पहले, हमने अपनी सेवाओं के प्रोटोटाइप डिब्बे बनाए और उनमें से प्रत्येक को ग्राहक के सभी आवश्यक गुणों और चल रही प्रक्रिया (प्रवाह - इसका अर्थ है तार्किक प्रक्रिया, नौकरी, ओएस प्रक्रिया नहीं) को पारित किया:

@Service @Scope("prototype") public class ServiceA { private Customer customer; private ReloadType reloadType; private ServiceB serviceB; @Autowired private ApplicationContext context; public ServiceA(final Customer customer, final ReloadType reloadType) { this.customer = customer; this.reloadType = reloadType; } @PostConstruct public void init(){ serviceB = (ServiceB) context.getBean("serviceB",customer, reloadType); } public void doSomethingInteresting(){ doSomthingWithCustomer(customer,reloadType); serviceB.doSomethingBoring(); } private void doSomthingWithCustomer(final Customer customer, final ReloadType reloadType) { } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 @Service @Scope("prototype") public class ServiceB { private Customer customer; private ReloadType reloadType; public ServiceB(final Customer customer, final ReloadType reloadType) { this.customer = customer; this.reloadType = reloadType; } public void doSomethingBoring(){ } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

  //... ServiceA serviceA = (ServiceA) context.getBean("serviceA",customer, ReloadType.FullReaload); serviceA.doSomethingInteresting(); //...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह असुविधाजनक है - पहले, आप बिन बनाते समय संख्या या मापदंडों के प्रकार में गलती कर सकते हैं

दूसरा बॉयलर कोड का एक बहुत



इसलिए, हमने अपने दायरे को सेम बना दिया - "ग्राहक"।



यह विचार है: मैं एक निश्चित "संदर्भ" बनाता हूं - एक ऐसी वस्तु जो इस बारे में जानकारी संग्रहीत करती है कि कौन सी प्रक्रिया अभी चल रही है (कौन सा ग्राहक, किस प्रकार की प्रक्रिया - यह सभी सेवाओं को जानना आवश्यक है) और इसे थ्रेडलोक में संग्रहीत करें।

अपने दायरे के लिए बीन बनाते समय, मैं इस संदर्भ को वहां इंजेक्ट करता हूं।



उसी संदर्भ में, पहले से ही बनाई गई बीन्स की एक सूची संग्रहीत की जाती है ताकि प्रत्येक बिन पूरी प्रक्रिया के लिए केवल एक बार बनाया जाए।



जब प्रक्रिया समाप्त हो जाती है, तो मैं थ्रेडलोक को साफ करता हूं और सभी बीन्स को कचरा कलेक्टर द्वारा एकत्र किया जाता है।



ध्यान दें कि मेरे कार्यक्षेत्र में सभी सेम को कुछ इंटरफ़ेस लागू करना होगा। यह केवल संदर्भ को इंजेक्ट करने के लिए आवश्यक है।



तो, xml में हमारे दायरे की घोषणा करें:

 .. <bean id="customerScope" class="com.scope.CustomerScope"/> <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer"> <property name="scopes"> <map> <entry key="customer" value-ref="customerScope"/> </map> </property> </bean> ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम अपना दायरा लागू करते हैं:

 public class CustomerScope implements Scope { @Override public Object get(String name, ObjectFactory<?> objectFactory) { CustomerContext context = resolve(); Object result = context.getBean(name); if (result == null) { result = objectFactory.getObject(); ICustomerScopeBean syncScopedBean = (ICustomerScopeBean) result; syncScopedBean.setContext(context); Object oldBean = context.setBean(name, result); if (oldBean != null) { result = oldBean; } } return result; } @Override public Object remove(String name) { CustomerContext context = resolve(); return context.removeBean(name); } protected CustomerContext resolve() { return CustomerContextThreadLocal.getCustomerContext(); } @Override public void registerDestructionCallback(String name, Runnable callback) { } @Override public Object resolveContextualObject(String key) { return null; } @Override public String getConversationId() { return resolve().toString(); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि हम देखते हैं, समान प्रक्रिया (प्रवाह) के भीतर समान बिन उदाहरणों का उपयोग किया जाता है (यानी यह दायरा वास्तव में मानक नहीं है - प्रोटोटाइप में हर बार नए बनाए जाएंगे, सिंगलटन में - वही)।

और संदर्भ स्वयं थ्रेडलोक से लिया गया है:

 public class CustomerContextThreadLocal { private static ThreadLocal<CustomerContext> customerContext = new ThreadLocal<>(); public static CustomerContext getCustomerContext() { return customerContext.get(); } public static void setSyncContext(CustomerContext context) { customerContext.set(context); } public static void clear() { customerContext.remove(); } private CustomerContextThreadLocal() { } public static void setSyncContext(Customer customer, ReloadType reloadType) { setSyncContext(new CustomerContext(customer, reloadType)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह हमारे सभी बीन्स और इसके अमूर्त कार्यान्वयन के लिए एक इंटरफ़ेस बनाने के लिए बना हुआ है:

 public interface ICustomerScopeBean { void setContext(CustomerContext context); } public class AbstractCustomerScopeBean implements ICustomerScopeBean { protected Customer customer; protected ReloadType reloadType; @Override public void setContext(final CustomerContext context) { customer = context.getCustomer(); reloadType = context.getReloadType(); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और उसके बाद, हमारी सेवाएं बहुत अधिक सुंदर लगती हैं:

 @Service @Scope("customer") public class ServiceA extends AbstractCustomerScopeBean { @Autowired private ServiceB serviceB; public void doSomethingInteresting() { doSomthingWithCustomer(customer, reloadType); serviceB.doSomethingBoring(); } private void doSomthingWithCustomer(final Customer customer, final ReloadType reloadType) { } } @Service @Scope("customer") public class ServiceB extends AbstractCustomerScopeBean { public void doSomethingBoring(){ } } //.... CustomerContextThreadLocal.setSyncContext(customer, ReloadType.FullReaload); ServiceA serviceA = context.getBean(ServiceA.class); serviceA.doSomethingInteresting(); //.....
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सवाल उठ सकता है - हम थ्रेडलोकल का उपयोग करते हैं - लेकिन क्या होगा अगर हम अतुल्यकालिक तरीकों को कहते हैं?

मुख्य बात यह है कि पूरे बीन का पेड़ समकालिक रूप से बनाया गया है, फिर @Autowired सही ढंग से काम करेगा।

और यदि कोई भी विधि @ Async से शुरू होती है, तो यह डरावना नहीं है, सब कुछ काम करेगा, क्योंकि सेम पहले से ही बनाए गए हैं।



यह सत्यापित करने के लिए एक परीक्षण लिखना भी अच्छा है कि "ग्राहक" गुंजाइश के साथ सभी सेम ICustomerScopeBean को लागू करें और इसके विपरीत:

  @ContextConfiguration(locations = {"classpath:beans.xml"}, loader = GenericXmlContextLoader.class) @RunWith(SpringJUnit4ClassRunner.class) public class CustomerBeanScopetest { @Autowired private AbstractApplicationContext context; @Test public void testScopeBeans() throws ClassNotFoundException { ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames(); for (String beanDef : beanDefinitionNames) { BeanDefinition def = beanFactory.getBeanDefinition(beanDef); String scope = def.getScope(); String beanClassName = def.getBeanClassName(); if (beanClassName == null) continue; Class<?> aClass = Class.forName(beanClassName); if (ICustomerScopeBean.class.isAssignableFrom(aClass)) assertTrue(beanClassName + " should have scope 'customer'", scope.equals("customer")); if (scope.equals("customer")) assertTrue(beanClassName + " should implement 'ICustomerScopeBean'", ICustomerScopeBean.class.isAssignableFrom(aClass)); } } }