XML के बिना स्प्रिंग फ्रेमवर्क ... बिल्कुल!

एनोटेशन के साथ सब कुछ और सब कुछ परिभाषित करने के वर्तमान युग के प्रकाश में, मैं आपको स्प्रिंग फ्रेमवर्क और एनोटेटिंग परियोजनाओं की संभावनाओं के बारे में एक लेख प्रदान करता हूं। लगभग। ट्रांस।
शुरुआत में EJB 2.1 था, जहाँ भी संभव हो बड़ी संख्या में XML फ़ाइलों के साथ। यह कहना अतिशयोक्ति नहीं होगी कि व्यावसायिक तर्क के लिए कोड की एक पंक्ति पर आपको फ्रेमवर्क से कोड की कम से कम 10 लाइनें और दो XML पेज लिखने होंगे। सामान्य रूप से स्थानीय और दूरस्थ इंटरफेस, मैनुअल JNDI- लुकिंग, मल्टी-लेवल ट्राय-कैच, रिमोटएक्सैप्शन ... एंटरप्राइज के लिए चेक। यहां तक ​​कि उपकरण इस पूरे "रसोई" की स्वचालित पीढ़ी के लिए उपयुक्त थे।

फिर कुछ लोगों ने स्प्रिंग फ्रेमवर्क बनाया। PortableRemoteObject.narrow () की अस्पष्ट जातियों के बाद, यह ताजी हवा की सांस बन गया। समय बीत गया (वैसे, किसी को याद है कि कितने साल पहले JRE की आखिरी बड़ी रिलीज़ हुई थी?) और सूरज को सबक का एहसास हुआ। EJB 3.0 स्प्रिंग, एक्सएमएल-फ्री से भी सरल था, एनोटेशन, निर्भरता इंजेक्शन के साथ। 3.1 सरलीकरण की दिशा में एक और बड़ा कदम था। तार्किक रूप से, EJB को अब स्प्रिंग ऑफर के हिस्से के रूप में माना जा सकता है, और मुझे काफी आश्चर्य है कि सादे स्प्रिंग में कोई EJB कार्यान्वयन क्यों नहीं है (ओह, प्रतीक्षा करें ...), बॉक्स JPA 1.0 / 2.0, JSR-250 से अपना समर्थन दिया , JSR-330, JAX-WS / RS और अधिक। स्प्रिंग फ्रेमवर्क आज एक धीमी, भारी और फ्रेम को बनाए रखने के लिए मुश्किल के रूप में माना जाता है, मुख्यतः एक्सएमएल डिस्क्रिप्टर के कारण। सामान्य तौर पर, स्प्रिंग एक जेपिंग लड़के के रूप में जेईई फ्रेमवर्क का विरोध करता है।

मुझे राजनीति पसंद नहीं है और मैं लंबे निबंध लिखकर अपने पसंदीदा ढांचे का बचाव नहीं करता। इसके बजाय, मैं एक साधारण लेकिन तुच्छ स्प्रिंग एप्लिकेशन नहीं लूंगा और XML के बिना इसे फिर से लिखूंगा। एक्सएमएल के बिना बिल्कुल, एक भी लाइन के बिना।
लेख के लिए, मैंने JDBC, JMS और JMX के साथ बसंत (xml शाखा में नियमित रूप से संस्करण, मास्टर में अंतिम संस्करण) में एक बहुत ही सरल वेब एप्लिकेशन लिखा, ताकि कार्य को सरल न किया जा सके। प्रत्येक परिवर्तन रिपॉजिटरी के लिए एक अलग प्रतिबद्धता में परिलक्षित होगा, और, कदम से कदम, मैं XML से छुटकारा पाऊंगा जब तक कि यह पूरी तरह से चला गया। चलिए शुरू करते हैं।

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:mbean-export /> <bean id="fooService" class="com.blogspot.nurkiewicz.FooService"> <property name="jmsOperations" ref="jmsTemplate" /> </bean> <bean id="fooRequestProcessor" class="com.blogspot.nurkiewicz.FooRequestProcessor"> <property name="fooRepository" ref="fooRepository" /> </bean> <bean id="fooRepository" class="com.blogspot.nurkiewicz.FooRepository" init-method="init"> <property name="jdbcOperations" ref="jdbcTemplate" /> </bean> <!-- JDBC --> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="org.h2.Driver" /> <property name="url" value="jdbc:h2:~/workspace/h2/spring-noxmal;DB_CLOSE_ON_EXIT=FALSE;TRACE_LEVEL_FILE=4;AUTO_SERVER=TRUE" /> <property name="username" value="sa" /> <property name="password" value="" /> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <constructor-arg ref="dataSource" /> </bean> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <constructor-arg ref="dataSource" /> </bean> <tx:annotation-driven /> <!-- JMS --> <bean id="jmsConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory"> <constructor-arg> <bean class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp://localhost:61616" /> </bean> </constructor-arg> </bean> <amq:queue id="requestsQueue" physicalName="requests" /> <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"> <constructor-arg ref="jmsConnectionFactory" /> <property name="defaultDestination" ref="requestsQueue" /> </bean> <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"> <property name="connectionFactory" ref="jmsConnectionFactory" /> <property name="destination" ref="requestsQueue" /> <property name="sessionTransacted" value="true"/> <property name="concurrentConsumers" value="5"/> <property name="messageListener"> <bean class="org.springframework.jms.listener.adapter.MessageListenerAdapter"> <constructor-arg ref="fooRequestProcessor" /> <property name="defaultListenerMethod" value="process"/> </bean> </property> </bean> </beans> 

उपयोगकर्ता बीन्स की एक जोड़ी, लेनदेन और जेएमएस के साथ जेडीबीएस, भेजना और प्राप्त करना। विवरण विशेष रूप से महत्वपूर्ण नहीं हैं - जेएमएक्स के माध्यम से सेम में से एक जेएमएस संदेश भेजता है, संदेश प्राप्त होता है और डेटाबेस में रखा जाता है (जारी)।

स्प्रिंग में एक्सएमएल परत को कम करने के लिए सबसे आम और अच्छी तरह से स्थापित दृष्टिकोण सेवा और संसाधन एनोटेशन के साथ-साथ उपयोग करना है <संदर्भ: उपयोगकर्ता बीन्स ( परिवर्तन ) के लिए घटक-स्कैन />:

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:mbean-export /> <context:component-scan base-package="com.blogspot.nurkiewicz"/> <!-- JDBC --> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="org.h2.Driver" /> <property name="url" value="jdbc:h2:~/workspace/h2/spring-noxmal;DB_CLOSE_ON_EXIT=FALSE;TRACE_LEVEL_FILE=4;AUTO_SERVER=TRUE" /> <property name="username" value="sa" /> <property name="password" value="" /> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <constructor-arg ref="dataSource" /> </bean> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <constructor-arg ref="dataSource" /> </bean> <tx:annotation-driven /> <!-- JMS --> <bean id="jmsConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory"> <constructor-arg> <bean class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp://localhost:61616" /> </bean> </constructor-arg> </bean> <amq:queue id="requestsQueue" physicalName="requests" /> <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"> <constructor-arg ref="jmsConnectionFactory" /> <property name="defaultDestination" ref="requestsQueue" /> </bean> <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"> <property name="connectionFactory" ref="jmsConnectionFactory" /> <property name="destination" ref="requestsQueue" /> <property name="sessionTransacted" value="true"/> <property name="concurrentConsumers" value="5"/> <property name="messageListener"> <bean class="org.springframework.jms.listener.adapter.MessageListenerAdapter"> <constructor-arg ref="fooRequestProcessor" /> <property name="defaultListenerMethod" value="process"/> </bean> </property> </bean> </beans> 

XML की कम 10 लाइनें, कुछ खास नहीं ... और उपयोगकर्ता-सेम?

 @Service public class FooRepository { @Resource private JdbcOperations jdbcOperations; @PostConstruct public void init() { log.info("Database server time is: {}", jdbcOperations.queryForObject("SELECT CURRENT_TIMESTAMP", Date.class)); } //... } 

सेटर और इनिट मेथड को एनोटेशन द्वारा बदल दिया जाता है। तो आगे क्या है? अधिकांश लोग-जो पसंद करते हैं-एनोटेशन उनके लॉरेल पर आराम करते हैं, लेकिन जैसा कि आप देख सकते हैं, बहुत सारे एक्सएमएल रहते हैं। अब सवाल यह है कि तीसरे पक्ष की चीजें जैसे कनेक्शन पूल, आदि के मामले में एनोटेशन का उपयोग कैसे किया जाए?
यहीं से शुरू होती है मस्ती। पहले हमें डेटा स्रोत XML से छुटकारा पाने और इन सभी को बदलने की आवश्यकता है ... ( परिवर्तन )

 import javax.sql.DataSource; import org.apache.commons.dbcp.BasicDataSource; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class ContextConfiguration { @Bean public DataSource dataSource() { final BasicDataSource ds = new BasicDataSource(); ds.setDriverClassName("org.h2.Driver"); ds.setUrl("jdbc:h2:~/workspace/h2/spring-noxmal;DB_CLOSE_ON_EXIT=FALSE;TRACE_LEVEL_FILE=4;AUTO_SERVER=TRUE"); ds.setUsername("sa"); return ds; } } 

@Configuration, Bean , dataSource (), यह क्या है ...?!? लेकिन यह वैसा ही काम करता है जैसा आपने सोचा था: स्प्रिंग कॉन्टेक्टकोनफिगरेशन क्लास और बीन के रूप में एनोटेट किए गए सभी तरीकों को ढूंढता है। प्रत्येक ऐसी विधि XML-ev <bean ...> (यहां तक ​​कि स्कोप , @DendendsOn और Lazy ) के बराबर है, इसलिए हम डेटा स्रोत बीन की XML घोषणा को हटा सकते हैं। यद्यपि, वास्तव में, आप JdbcTemplate और लेनदेन प्रबंधक ( परिवर्तन ) से छुटकारा पा सकते हैं:

 @Bean public JdbcOperations jdbcOperations() { return new JdbcTemplate(dataSource()); } @Bean public PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(dataSource()); } 

ध्यान दें कि डेटा स्रोत-बिन को अन्य डिब्बे में इंजेक्ट करना कितना आसान है। आपके पास एक विधि है जो डेटा स्रोत बनाती है, और आपके पास दो विधियाँ हैं जिन्हें इस डेटा स्रोत (JdbcTemplate और लेनदेन प्रबंधक) की आवश्यकता है। यह कभी आसान नहीं है, और शायद आपकी प्रेमिका ने निर्भरता इंजेक्शन (उम, गुइसे? ) लागू किया होगा।

एक बात अब आपको परेशान करना चाहिए ... यदि आप डेटासोर्स () को दो बार कॉल करते हैं, तो क्या इसका मतलब है कि डेटा स्रोत के दो स्वतंत्र उदाहरण बनाए गए हैं? यह बिल्कुल नहीं है कि हम क्या चाहते हैं। इसने मुझे हैरान कर दिया, लेकिन एक बार फिर वसंत एक स्मार्ट जानवर बन गया। स्कोप एनोटेशन नहीं पाए जाने के बाद, वह इस बात पर विचार करना शुरू कर देता है कि डेटा स्रोत सिंगलटन होना चाहिए और, डेटा स्रोत () विधि पर थोड़ा सीजीएलआईबी प्रॉक्सिंग जादू लागू करते हुए, कॉल की संख्या को एक तक सीमित कर देता है। ठीक है, या अधिक विशेष रूप से, आप इसे कई बार कॉल कर सकते हैं, लेकिन उसी बीन को वापस कर सकते हैं। कूल!
परिणामस्वरूप, XML कॉन्फ़िगरेशन निम्न के लिए:

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <context:mbean-export /> <context:component-scan base-package="com.blogspot.nurkiewicz"/> <!-- JDBC --> <tx:annotation-driven /> <!-- JMS --> <bean id="jmsConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory"> <constructor-arg> <bean class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp://localhost:61616" /> </bean> </constructor-arg> </bean> <amq:queue id="requestsQueue" physicalName="requests" /> <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"> <constructor-arg ref="jmsConnectionFactory" /> <property name="defaultDestination" ref="requestsQueue" /> </bean> <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"> <property name="connectionFactory" ref="jmsConnectionFactory" /> <property name="destination" ref="requestsQueue" /> <property name="sessionTransacted" value="true"/> <property name="concurrentConsumers" value="5"/> <property name="messageListener"> <bean class="org.springframework.jms.listener.adapter.MessageListenerAdapter"> <constructor-arg ref="fooRequestProcessor" /> <property name="defaultListenerMethod" value="process"/> </bean> </property> </bean> </beans> 

अब आप बंद कर सकते हैं और सोच सकते हैं कि कॉन्फ़िगरेशन में शेष सेम को फिर से कैसे लिखा जाए। यह इसके लायक नहीं है, सब कुछ पारदर्शी ( परिवर्तन ) है।

 @Bean public ConnectionFactory jmsConnectionFactory() { final ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(); factory.setBrokerURL("tcp://localhost:61616"); return new PooledConnectionFactory(factory); } @Bean public Queue requestsQueue() { return new ActiveMQQueue("requests"); } @Bean public JmsOperations jmsOperations() { final JmsTemplate jmsTemplate = new JmsTemplate(jmsConnectionFactory()); jmsTemplate.setDefaultDestination(requestsQueue()); return jmsTemplate; } 

DefaultMessageListenerContainer घोषणा में अनाम आंतरिक डिब्बे होते हैं जो मूल बीन के अंदर एक बार उपयोग किए जाते हैं। क्रम में निजी विधि ( परिवर्तन ):

 @Bean public AbstractJmsListeningContainer jmsContainer() { final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer(); container.setConnectionFactory(jmsConnectionFactory()); container.setDestination(requestsQueue()); container.setSessionTransacted(true); container.setConcurrentConsumers(5); container.setMessageListener(messageListenerAdapter()); return container; } private MessageListenerAdapter messageListenerAdapter() { final MessageListenerAdapter adapter = new MessageListenerAdapter(fooRequestProcessor); adapter.setDefaultListenerMethod("process"); return adapter; } 

टिप्पणी करने के लिए कुछ भी नहीं है क्योंकि वसंत में सादे जावा कॉन्फ़िगरेशन तुच्छ और सरल है - कोड खुद के लिए बोलता है। मामले में आप भ्रमित हो गए, हम इस पर आए:

<? xml संस्करण = "1.0" एन्कोडिंग = "UTF-8"?>
<सेम xmlns = " www.springframework.org/schema/beans "
xmlns: xsi = " www.w3.org/2001/XMLSchema-instance "
xmlns: tx = " www.springframework.org/schema/tx "
xmlns: संदर्भ = " www.springframework.org/schema/context "
xsi: schemaLocation = " www.springframework.org/schema/beans www.springframework.org/schema/beans/spring-beans-3.0.xsd
www.springframework.org/schema/tx www.springframework.org/schema/tx/spring-tx-2.5.xsd
www.springframework.org/schema/context www.springframework.org/schema/context/spring-context.xsd »>

<संदर्भ: mbean-export />

<संदर्भ: घटक-स्कैन बेस-पैकेज = "com.blogspot.nurkiewicz" />

<tx: एनोटेशन-चालित />



ईमानदारी से, यह सब बहुत मुश्किल नहीं था, लेकिन XML की आखिरी कुछ पंक्तियों को वास्तव में छुटकारा पाना मुश्किल था। मेरा विश्वास करो, आप इन सुंदर छोटे नाम-संचालित विज्ञापनों के साथ मुझे जो करना चाहते थे, वह नहीं करना चाहते। लेकिन कुछ मिनटों के बाद, बुरे अनुभवों के एक जोड़े, और स्कैन किए गए स्प्रिंग कोड का एक गुच्छा, मैंने आखिरकार जेएमएक्स घोषणाओं ( परिवर्तन ) और लेनदेन ( परिवर्तन ) को हटा दिया। यह निर्दोष लग रहा है और मुझे खुशी है कि आपको इसे स्वयं प्राप्त करने के लिए स्प्रिंग कोड में खुदाई करने की आवश्यकता नहीं थी:

 @Bean public AnnotationMBeanExporter annotationMBeanExporter() { return new AnnotationMBeanExporter(); } @Bean public TransactionAttributeSource annotationTransactionAttributeSource() { return new AnnotationTransactionAttributeSource(); } @Bean public TransactionInterceptor transactionInterceptor() { return new TransactionInterceptor(transactionManager(), annotationTransactionAttributeSource()); } 

वहां तुम जाओ। यह सेम और web.xml स्निपेट के स्थान के बारे में स्प्रिंग के लिए XML निर्देशों को हटाने के लिए बना हुआ है:

 <context:component-scan base-package="com.blogspot.nurkiewicz"/> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app> 

वेब वातावरण में सामान्य रूप से स्प्रिंग शुरू करने का कोई अन्य तरीका नहीं है, लेकिन आपको वेब कंटेनर को यह बताना होगा कि स्प्रिंग की आवश्यकता है। मुझे पता है, मुझे पता है, मैंने वादा किया था कि कोई एक्सएमएल नहीं होगा, ठीक है, मैंने झूठ बोला, और अब ... माफ करना, ठीक है? व्यापार ... हाँ, बस मजाक कर रहे हैं।  आइए इससे भी छुटकारा पाएं। सेकंड के एक जोड़े! खैर ... हालाँकि यह इस बात पर निर्भर करता है कि आप कितनी जल्दी नवीनतम टॉस्क 7 या दूसरे जेएसआर 315 को डाउनलोड करते हैं- सक्षम (सर्वलेट 3.0 के रूप में जाना जाता है) वेब सर्वर ...

वेब टुकड़े एक प्रौद्योगिकी है जो सर्वलेट कंटेनरों में विभिन्न वेब फ्रेमवर्क को एकीकृत करने की अनुमति देता है। यदि आपके पास चौखटे के साथ काम करने का अनुभव है, तो आप जानते हैं कि उन सभी को वेब .xml में एक विशेष सर्वलेट, फ़िल्टर या श्रोता विवरण की आवश्यकता होती है। ज्यादातर मामलों में, यह एकमात्र समय है जब एक सर्वलेट निर्भरता होती है और स्प्रिंग कोई अपवाद नहीं है। वेब टुकड़ों का सार यह है कि वे डेवलपर्स को इससे मुक्त करने की कोशिश कर रहे हैं। सर्वलेट 3.0 कंटेनरों को सभी JAR / WEB-INF / lib में स्कैन करना चाहिए और यदि किसी भी JAR में web-fragment.xml / META-INF है, तो यह web.xml में पंजीकृत होगा।

समझ गया, मैं कहाँ जा रहा हूँ? क्या होगा अगर हम XML के बिना बस चलाने के लिए एक छोटे वेब टुकड़े के साथ एक छोटा सा JAR बनाएं? तार संरचना:

 . |-- META-INF `-- WEB-INF |-- classes | |-- com | | `-- blogspot | | `-- nurkiewicz | | |-- ContextConfiguration.class | | |-- FooRepository.class | | |-- FooRequestProcessor.class | | |-- FooService$1.class | | `-- FooService.class | `-- logback.xml |-- lib | |-- spring-web-3.0.5.RELEASE.jar | |-- spring-web-fragment-0.0.1-SNAPSHOT.jar | | `-- META-INF | | |-- MANIFEST.MF | | |-- web-fragment-context.xml | | `-- web-fragment.xml | `-- spring-beans-3.0.5.RELEASE.jar `-- web.xml 

वसंत-वेब-टुकड़े का एकमात्र उद्देश्य * है। कंटेनर में वेब-टुकड़ा -xml प्रदान करने में जार:

 <web-fragment xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd" version="3.0"> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath*:/META-INF/web-fragment-context.xml</param-value> </context-param> </web-fragment> 

एक नया तत्व वेब-टुकड़ा-संदर्भ है। xml स्प्रिंग संदर्भ फ़ाइल। हम डिफ़ॉल्ट रूप से (/WEB-INF/applicationContext.xml) का उपयोग नहीं कर सकते, क्योंकि यह फ़ाइल अब (!) नहीं है। लेकिन हमारा छोटा JAR ऐसा लगता है जैसे यह इसके लिए सबसे अच्छी जगह थी:

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <context:component-scan base-package="." /> </beans> 

पैकेज की घोषणा " सतर्कता का कारण बनता है। यह बहुत दुखद है, लेकिन मैंने कम से कम एक पैकेज की घोषणा में आवश्यकता के आसपास जाने की कोशिश की। यह आवश्यकता शायद उचित है (मुझे लगता है कि CLASSPATH स्कैन में कुछ समय लगता है), लेकिन मैं सिर्फ अपने पैकेज का संकेत नहीं दे सकता, अन्यथा मुझे प्रत्येक नई परियोजना के लिए इस घोषणा को बदलना होगा। लेकिन यह वेब टुकड़ों के साथ दृष्टिकोण के मुख्य लाभ के खिलाफ जाता है - जब दो छोटे XML फ़ाइलों के साथ एक जार बनाते हैं, तो इसका उपयोग सभी परियोजनाओं के लिए किया जा सकता है। जरूरत है कि इसे अपने WAR के पुस्तकालयों की सूची में शामिल करें और POJO को सेवा के रूप में एनोटेट करना शुरू करें (और / या @Configuration का उपयोग करके)।

यदि यह बॉक्स से स्प्रिंग प्रदान करता है (यदि आपको विचार, वोट पसंद है ) के बीच उपलब्ध होगा, तो शुरुआती लोग वसंत में यात्रा करने का आनंद लेने में सक्षम होंगे जैसे ही वे pom.xml में स्प्रिंग जोड़ते हैं। वास्तव में, pom.xml को विभिन्न भाषाओं में , logback.xml की तरह लिखा जा सकता है। अरे, कोई एक्सएमएल नहीं! क्या आपको यकीन है? क्या आपको XML या Java ज्यादा पसंद है? या शायद ग्रूवी? कृपया चुप रहें। स्प्रिंग आपको अपनी इच्छानुसार उपयोग करने के लिए सरल और सरल होने का अवसर देता है। इतना सरल किए बिना कि कार्यक्षमता को छोटा कर दिया जाएगा।