spring ट्यूटोरियल
वसंत के साथ शुरू हो रही है

टिप्पणियों

संस्करण

सेटअप (XML कॉन्फ़िगरेशन)

हैलो स्प्रिंग बनाने के लिए कदम:

0. स्प्रिंग बूट की जांच करें कि क्या आपकी आवश्यकताओं के अनुरूप बेहतर होगा।
1. सही निर्भरता के साथ एक परियोजना स्थापित की है। यह अनुशंसा की जाती है कि आप मावेन या ग्रैडल का उपयोग कर रहे हैं।
2. एक POJO वर्ग बनाएं, जैसे Employee.java
3. एक XML फ़ाइल बनाएँ जहाँ आप अपने वर्ग और चर को परिभाषित कर सकते हैं। जैसे beans.xml
4. अपना मुख्य वर्ग बनाएं जैसे Customer.java
5. एक निर्भरता के रूप में वसंत-सेम (और इसकी सकर्मक निर्भरता!) को शामिल करें।

Employee.java : Employee.java

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}

beans.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>

Customer.java : Customer.java

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}

उदाहरण के लिए कोर स्प्रिंग सुविधाएँ दिखाना

विवरण

यह एक आत्म निहित उदाहरण है / प्रदर्शन सहित: न्यूनतम निर्भरता की आवश्यकता, जावा विन्यास , एनोटेशन द्वारा बीन की घोषणा और जावा विन्यास, कंस्ट्रक्टर द्वारा और संपत्ति द्वारा डिपेंडेंसी इंजेक्शन , और प्री / पोस्ट हुक।

निर्भरता

वर्गपथ में इन निर्भरताओं की आवश्यकता है:

1. वसंत-कोर
2. वसंत-प्रसंग
3. वसंत-सेम
4. वसंत-aop
5. वसंत अभिव्यक्ति
6. कॉमन्स-लॉगिंग

मुख्य वर्ग

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

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}

एप्लिकेशन कॉन्फ़िगरेशन फ़ाइल

कॉन्फ़िगरेशन वर्ग @Configuration द्वारा एनोटेट किया @Configuration और इसका उपयोग प्रारंभिक अनुप्रयोग संदर्भ में एक पैरामीटर के रूप में किया जाता है। कॉन्फ़िगरेशन श्रेणी के वर्ग स्तर पर @ComponentScan एनोटेशन का उपयोग करके पंजीकृत बीन्स और निर्भरता के लिए स्कैन किए जाने वाले पैकेज की ओर @ComponentScan । अंत में @Bean एनोटेशन कॉन्फ़िगरेशन क्लास में सेम की परिभाषा के रूप में कार्य करता है।

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}

बीन घोषणा द्वारा एनोटेशन

@Component एनोटेशन घटक स्कैनिंग के दौरान पंजीकरण के लिए उपलब्ध स्प्रिंग बीन के रूप में POJO का सीमांकन करने का कार्य करता है।

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}

आवेदन विन्यास द्वारा बीन घोषणा

ध्यान दें कि हमें अपने POJO को एनोटेट या अन्यथा चिह्नित करने की आवश्यकता नहीं है क्योंकि बीन घोषणा / परिभाषा एप्लिकेशन कॉन्फ़िगरेशन क्लास फ़ाइल में हो रही है।

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}

कंस्ट्रक्टर इंजेक्शन

ध्यान दें कि @Autowired एनोटेशन कंस्ट्रक्टर स्तर पर सेट किया गया है। यह भी ध्यान दें कि जब तक कि डिफ़ॉल्ट रूप से परिभाषित नहीं किया जाता है, तब तक डिफ़ॉल्ट BeanToBeInjected बीन के प्रकार के आधार पर हो रही है (इस उदाहरण में BeanToBeInjected )।

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}

संपत्ति इंजेक्शन

ध्यान दें कि @Autowired एनोटेशन सेटर विधि को सीमांकित करता है जिसका नाम JavaBeans मानक का अनुसरण करता है।

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}

PostConstruct / PreDestroy हुक

हम @PostConstruct और @PreDestroy हुक द्वारा बीन के विनाश और विनाश को रोक सकते हैं।

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}

स्प्रिंग फ्रेमवर्क क्या है, हमें इसके लिए क्यों जाना चाहिए?

स्प्रिंग एक ढांचा है, जो कक्षाओं का गुच्छा प्रदान करता है, इसके उपयोग से हमें अपने कोड में बॉयलर प्लेट तर्क लिखने की आवश्यकता नहीं है, इसलिए वसंत जे 2 पर एक सार परत प्रदान करता है।

उदाहरण के लिए सरल JDBC में अनुप्रयोग प्रोग्रामर के लिए जिम्मेदार है

1. ड्राइवर वर्ग लोड हो रहा है
2. संबंध बनाना
3. कथन वस्तु बनाना
4. अपवादों को संभालना
5. क्वेरी बनाना
6. निष्पादन योग्य क्वेरी
7. कनेक्शन बंद करना

जिसे बॉयलरप्लेट कोड के रूप में माना जाता है क्योंकि प्रत्येक प्रोग्रामर एक ही कोड लिखता है। इसलिए सरलता के लिए फ्रेमवर्क बॉयलरप्लेट लॉजिक का ध्यान रखता है और प्रोग्रामर को केवल बिजनेस लॉजिक लिखना होता है। इसलिए स्प्रिंग फ्रेमवर्क का उपयोग करके हम कोड की न्यूनतम लाइनों के साथ तेजी से परियोजनाओं को विकसित कर सकते हैं, बिना किसी बग के, विकास लागत और समय भी कम हो जाता है।

तो क्यों वसंत का चयन करने के लिए स्ट्रट्स के रूप में वहाँ है

अकड़ एक ऐसा ढांचा है जो केवल वेब पहलुओं का समाधान प्रदान करता है और अकड़ स्वभाव में आक्रामक है। स्ट्रट्स के ऊपर स्प्रिंग की कई विशेषताएं हैं इसलिए हमें स्प्रिंग को चुनना होगा।

1. स्प्रिंग प्रकृति में गैर-प्रमुख है: इसका मतलब है कि आपको किसी भी वर्ग को विस्तारित करने या अपनी कक्षा में किसी भी इंटरफेस को लागू करने की आवश्यकता नहीं है।
2. वसंत बहुमुखी है : इसका मतलब है कि यह आपकी परियोजना में किसी भी मौजूदा तकनीक के साथ एकीकृत कर सकता है।
3. वसंत परियोजना के अंत से अंत तक विकास प्रदान करता है: इसका मतलब है कि हम व्यापार परत, दृढ़ता परत जैसे सभी मॉड्यूल विकसित कर सकते हैं।
4. स्प्रिंग का वजन हल्का होता है : इसका मतलब है कि अगर आप किसी विशेष मॉड्यूल पर काम करना चाहते हैं, तो आपको पूरा स्प्रिंग सीखने की जरूरत नहीं है, केवल उस मॉड्यूल को सीखें (जैसे। स्प्रिंग जेडडीबी, स्प्रिंग डीएओ)
5. वसंत निर्भरता इंजेक्शन का समर्थन करता है ।
6. स्प्रिंग कई परियोजना विकास का समर्थन करता है जैसे: कोर जावा अनुप्रयोग, वेब अनुप्रयोग, वितरित अनुप्रयोग, एंटरप्राइज़ अनुप्रयोग।
7. स्प्रिंग क्रॉस कटिंग चिंताओं के लिए एस्पैक्ट ओरिएंटेड प्रोग्रामिंग का समर्थन करता है।

तो अंत में हम कह सकते हैं कि स्प्रिंग स्ट्रट्स का एक विकल्प है। लेकिन स्प्रिंग जे 2 ईई एपीआई का प्रतिस्थापन नहीं है, क्योंकि वसंत आपूर्ति वर्ग आंतरिक रूप से जे 2 ईई एपीआई कक्षाओं का उपयोग करता है। वसंत एक विशाल ढांचा है इसलिए इसे कई मॉड्यूलों में विभाजित किया गया है। स्प्रिंग कोर को छोड़कर कोई भी मॉड्यूल दूसरे पर निर्भर नहीं है। कुछ महत्वपूर्ण मॉड्यूल हैं

1. स्प्रिंग कोर
2. स्प्रिंग JDBC
3. स्प्रिंग एओपी
4. वसंत लेनदेन
5. स्प्रिंग ओआरएम
6. वसंत MVC