स्प्रिंग फ्रेमवर्क की व्यापक गाइड

Home PDF

यह ब्लॉग पोस्ट ChatGPT-4o की सहायता से लिखा गया है।

विषय सूची

परिचय

स्प्रिंग (Spring) जावा में एंटरप्राइज़-ग्रेड एप्लिकेशन बनाने के लिए सबसे लोकप्रिय फ्रेमवर्क्स में से एक है। यह जावा एप्लिकेशन विकसित करने के लिए व्यापक इंफ्रास्ट्रक्चर सपोर्ट प्रदान करता है। इस ब्लॉग में, हम स्प्रिंग इकोसिस्टम के विभिन्न पहलुओं को कवर करेंगे, जिसमें स्प्रिंग बूट (Spring Boot), डेटा प्रबंधन, RESTful सेवाएं बनाना, शेड्यूलिंग, टेस्टिंग, और स्प्रिंग एडवाइस API जैसी उन्नत सुविधाएं शामिल हैं।

स्प्रिंग बूट फ्रेमवर्क

स्प्रिंग बूट एक शक्तिशाली और लोकप्रिय फ्रेमवर्क है जो Java एप्लिकेशन के विकास को सरल और तेज़ बनाता है। यह स्प्रिंग फ्रेमवर्क का एक एक्सटेंशन है जो डेवलपर्स को स्टैंडअलोन, प्रोडक्शन-ग्रेड स्प्रिंग-आधारित एप्लिकेशन बनाने में मदद करता है। स्प्रिंग बूट का उपयोग करके, आप कम से कम कॉन्फ़िगरेशन के साथ तेज़ी से एप्लिकेशन विकसित कर सकते हैं।

स्प्रिंग बूट की मुख्य विशेषताएं:

स्प्रिंग बूट का उपयोग कैसे करें:

स्प्रिंग बूट का उपयोग करने के लिए, आप Spring Initializr का उपयोग करके एक नया प्रोजेक्ट बना सकते हैं। यह एक वेब-आधारित टूल है जो आपको अपने प्रोजेक्ट के लिए आवश्यक डिपेंडेंसीज़ और कॉन्फ़िगरेशन चुनने में मदद करता है।

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

उपरोक्त कोड एक बुनियादी स्प्रिंग बूट एप्लिकेशन को दर्शाता है। @SpringBootApplication एनोटेशन स्प्रिंग बूट को बताता है कि यह एक स्प्रिंग बूट एप्लिकेशन है और इसे ऑटो-कॉन्फ़िगर करना चाहिए।

स्प्रिंग बूट का उपयोग करके, आप तेज़ी से और कुशलता से Java एप्लिकेशन विकसित कर सकते हैं। यह डेवलपर्स के लिए एक बहुत ही उपयोगी और लोकप्रिय फ्रेमवर्क है।

Spring Boot के साथ शुरुआत करना

Spring Boot स्टैंड-अलोन, प्रोडक्शन-ग्रेड Spring-आधारित एप्लिकेशन बनाना आसान बनाता है। यह Spring प्लेटफॉर्म और तीसरे पक्ष की लाइब्रेरीज़ के प्रति एक राय रखता है, जिससे आप न्यूनतम कॉन्फ़िगरेशन के साथ शुरुआत कर सकते हैं।

डिपेंडेंसी इंजेक्शन

डिपेंडेंसी इंजेक्शन (DI) स्प्रिंग का एक मुख्य सिद्धांत है। यह ढीले युग्मित (loosely coupled) कंपोनेंट्स के निर्माण की अनुमति देता है, जिससे आपका कोड अधिक मॉड्यूलर और परीक्षण करने में आसान हो जाता है।

फ़ील्ड इंजेक्शन का उदाहरण:

  @Component
  public class UserService {
      
      @Autowired
      private UserRepository userRepository;
      
      // व्यावसायिक तरीके
  }

कंस्ट्रक्टर इंजेक्शन का उदाहरण:

  @Component
  public class UserService {
      
      private final UserRepository userRepository;

      @Autowired
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // व्यावसायिक तरीके
  }

मेथड इंजेक्शन का उदाहरण:

  @Component
  public class UserService {
      
      private UserRepository userRepository;

      @Autowired
      public void setUserRepository(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // व्यावसायिक तरीके
  }

उदाहरण:

@Component
public class EmailValidator {
    
    public boolean isValid(String email) {
        // वैधता जांच तर्क
        return true;
    }
}

उदाहरण:

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;

    public User findUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

ये एनोटेशन आपके Spring कॉन्फ़िगरेशन को अधिक पठनीय और संक्षिप्त बनाते हैं, और वे Spring फ्रेमवर्क को विभिन्न बीन्स के बीच निर्भरताओं को प्रबंधित और वायर करने में मदद करते हैं।

Spring में Events

Spring Framework में, events एक महत्वपूर्ण अवधारणा है जो application के विभिन्न घटकों के बीच संचार को सुविधाजनक बनाती है। Spring events का उपयोग करके, आप application में होने वाली विभिन्न घटनाओं (events) को पकड़ सकते हैं और उनके आधार पर कार्रवाई कर सकते हैं।

Spring Events का उपयोग कैसे करें?

Spring में events का उपयोग करने के लिए, आपको निम्नलिखित चरणों का पालन करना होगा:

  1. Event Class बनाएं: सबसे पहले, आपको एक custom event class बनानी होगी जो ApplicationEvent class को extend करती है।

    import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
    private String message;

    public CustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

  2. Event Publisher बनाएं: Event को publish करने के लिए, आपको ApplicationEventPublisher का उपयोग करना होगा।

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

@Component
public class CustomEventPublisher {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publishEvent(String message) {
        CustomEvent customEvent = new CustomEvent(this, message);
        applicationEventPublisher.publishEvent(customEvent);
    }
}

  3. Event Listener बनाएं: Event को सुनने (listen) और handle करने के लिए, आपको एक event listener बनाना होगा।

    import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener {

    @EventListener
    public void handleCustomEvent(CustomEvent event) {
        System.out.println("Received custom event - " + event.getMessage());
    }
}

  4. Event को Trigger करें: अब आप event publisher का उपयोग करके event को trigger कर सकते हैं।

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

@Component
public class EventTrigger implements CommandLineRunner {

    @Autowired
    private CustomEventPublisher customEventPublisher;

    @Override
    public void run(String... args) throws Exception {
        customEventPublisher.publishEvent("Hello, this is a custom event!");
    }
}

Spring Events के फायदे

Spring events एक शक्तिशाली तंत्र है जो application के विभिन्न हिस्सों के बीच संचार को सरल और प्रभावी बनाता है।

Spring की इवेंट मैकेनिज्म आपको एप्लिकेशन इवेंट्स को बनाने और सुनने की अनुमति देती है।

public MyCustomEvent(Object source, String message) {
    super(source);
    this.message = message;
}

यह एक कस्टम इवेंट क्लास का कंस्ट्रक्टर है। यह Object source और String message को पैरामीटर के रूप में लेता है। super(source) कॉल के माध्यम से यह पैरेंट क्लास के कंस्ट्रक्टर को कॉल करता है, और this.message को प्रदान किए गए message पैरामीटर के साथ इनिशियलाइज़ करता है।

  public String getMessage() {
      return message;
  }
}

      @EventListener
      public void handleMyCustomEvent(MyCustomEvent event) {
          System.out.println("Received spring custom event - " + event.getMessage());
      }
  }

public void publishCustomEvent(final String message) {
    System.out.println("कस्टम इवेंट प्रकाशित कर रहे हैं। ");
    MyCustomEvent customEvent = new MyCustomEvent(this, message);
    applicationEventPublisher.publishEvent(customEvent);
}
}

स्प्रिंग के साथ डेटा प्रबंधन

Spring Data JDBC

Spring Data JDBC, Spring Data परियोजना का एक हिस्सा है, जो JDBC (Java Database Connectivity) के साथ काम करने के लिए एक सरल और प्रभावी तरीका प्रदान करता है। यह डेटाबेस इंटरैक्शन को सरल बनाता है और डेवलपर्स को SQL क्वेरीज़ लिखने और डेटाबेस ऑपरेशन्स को मैनेज करने में मदद करता है।

Spring Data JDBC का उपयोग करके, आप अपने एप्लिकेशन में डेटाबेस ऑपरेशन्स को आसानी से इंटीग्रेट कर सकते हैं। यह डेटाबेस टेबल्स और Java ऑब्जेक्ट्स के बीच मैपिंग को सरल बनाता है और CRUD (Create, Read, Update, Delete) ऑपरेशन्स को सपोर्ट करता है।

मुख्य विशेषताएं:

उदाहरण:

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;

@Table("users")
public class User {
    @Id
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository<User, Long> {
    // Custom query methods can be defined here
}

इस उदाहरण में, User क्लास एक डेटाबेस टेबल users को रिप्रेजेंट करती है। UserRepository इंटरफ़ेस CrudRepository को एक्सटेंड करता है, जो CRUD ऑपरेशन्स को सपोर्ट करता है।

Spring Data JDBC का उपयोग करके, आप अपने एप्लिकेशन में डेटाबेस ऑपरेशन्स को आसानी से इंटीग्रेट कर सकते हैं और डेटाबेस इंटरैक्शन को सरल बना सकते हैं।

Spring Data JDBC सरल और प्रभावी JDBC एक्सेस प्रदान करता है।

Spring Data JPA

Spring Data JPA, JPA-आधारित रिपॉजिटरी को लागू करना आसान बनाता है।

Spring Data Redis

Spring Data Redis, Redis-आधारित डेटा एक्सेस के लिए बुनियादी ढांचा प्रदान करता है।

इस कोड को हिंदी में समझाएं:

यह एक Java मेथड है जो save नाम से है। यह मेथड दो पैरामीटर लेता है: key और value। इस मेथड का उद्देश्य Redis डेटाबेस में डेटा स्टोर करना है।

इस प्रकार, यह मेथड Redis में डेटा को स्टोर करने के लिए उपयोग किया जाता है।

  public Object find(String key) {
      return redisTemplate.opsForValue().get(key);
  }

इस कोड को हिंदी में समझाएं:

यह एक Java मेथड है जो find नाम से है। यह मेथड एक String प्रकार की key को पैरामीटर के रूप में लेता है और Object प्रकार का मान वापस करता है।

इस मेथड के अंदर, redisTemplate.opsForValue().get(key) का उपयोग किया गया है। यह Redis में संग्रहीत डेटा को पुनः प्राप्त करने के लिए है। redisTemplate एक Redis टेम्पलेट ऑब्जेक्ट है जो Redis के साथ इंटरैक्ट करने के लिए उपयोग किया जाता है। opsForValue() मेथड Redis में स्ट्रिंग ऑपरेशन्स के लिए उपयोग किया जाता है, और get(key) मेथड दिए गए key के लिए संग्रहीत मान को पुनः प्राप्त करता है।

इस प्रकार, यह मेथड Redis में संग्रहीत किसी विशेष key के लिए मान को वापस करता है।

लेन-देन और DAO समर्थन

Spring लेन-देन (transactions) और DAO (Data Access Object) सपोर्ट के प्रबंधन को सरल बनाता है।

public User findById(Long id) {
    return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", new Object[]{id}, new UserRowMapper());     
}
}

JDBC और ORM

JDBC (Java Database Connectivity) और ORM (Object-Relational Mapping) दोनों ही डेटाबेस के साथ इंटरैक्ट करने के लिए उपयोग किए जाने वाले टूल हैं, लेकिन इनके काम करने का तरीका और उद्देश्य अलग-अलग होता है।

JDBC (Java Database Connectivity)

JDBC एक Java API है जो डेटाबेस के साथ कनेक्टिविटी प्रदान करता है। यह डेवलपर्स को SQL क्वेरीज़ को डेटाबेस पर एक्ज़ीक्यूट करने और परिणाम प्राप्त करने की अनुमति देता है। JDBC का उपयोग करके, आप सीधे डेटाबेस के साथ इंटरैक्ट कर सकते हैं, लेकिन इसमें SQL क्वेरीज़ लिखने और डेटाबेस टेबल्स को मैनेज करने की ज़िम्मेदारी डेवलपर पर होती है।

उदाहरण:

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

while (rs.next()) {
    System.out.println(rs.getString("username"));
}

rs.close();
stmt.close();
conn.close();

ORM (Object-Relational Mapping)

ORM एक तकनीक है जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग और रिलेशनल डेटाबेस के बीच की खाई को पाटती है। ORM टूल्स (जैसे Hibernate, JPA) डेटाबेस टेबल्स को Java ऑब्जेक्ट्स में मैप करते हैं, जिससे डेवलपर्स को SQL क्वेरीज़ लिखने की आवश्यकता नहीं होती। ORM का उपयोग करके, आप डेटाबेस ऑपरेशन्स को ऑब्जेक्ट-ओरिएंटेड तरीके से कर सकते हैं।

उदाहरण:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;

    // Getters and Setters
}

// Using JPA to fetch users
EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-pu");
EntityManager em = emf.createEntityManager();
List<User> users = em.createQuery("SELECT u FROM User u", User.class).getResultList();

for (User user : users) {
    System.out.println(user.getUsername());
}

em.close();
emf.close();

JDBC और ORM में अंतर

दोनों ही तकनीकों के अपने फायदे और नुकसान हैं, और इनका चुनाव प्रोजेक्ट की आवश्यकताओं और डेवलपर की पसंद पर निर्भर करता है।

Spring, JDBC और ORM (ऑब्जेक्ट-रिलेशनल मैपिंग) के लिए व्यापक समर्थन प्रदान करता है।

(नोट: कोड ब्लॉक को अनुवादित नहीं किया जाता है क्योंकि यह प्रोग्रामिंग भाषा का हिस्सा है और इसे अपरिवर्तित रहना चाहिए।)

RESTful सेवाएं बनाना

Spring REST क्लाइंट्स

Spring REST क्लाइंट्स का उपयोग RESTful वेब सेवाओं के साथ बातचीत करने के लिए किया जाता है। Spring फ्रेमवर्क REST क्लाइंट्स के लिए कई विकल्प प्रदान करता है, जिनमें RestTemplate, WebClient, और RestClient शामिल हैं। ये क्लाइंट्स HTTP अनुरोधों को भेजने और प्रतिक्रियाओं को संसाधित करने के लिए उपयोग किए जाते हैं।

1. RestTemplate

RestTemplate एक सिंक्रोनस क्लाइंट है जो Spring 3 से उपलब्ध है। यह HTTP अनुरोधों को भेजने और प्रतिक्रियाओं को संसाधित करने के लिए उपयोग किया जाता है।

RestTemplate restTemplate = new RestTemplate();
String url = "https://api.example.com/data";
String response = restTemplate.getForObject(url, String.class);
System.out.println(response);

2. WebClient

WebClient एक नॉन-ब्लॉकिंग, रिएक्टिव क्लाइंट है जो Spring 5 में पेश किया गया था। यह अधिक आधुनिक और लचीला है, और यह अधिक जटिल अनुरोधों को संभालने के लिए उपयुक्त है।

WebClient webClient = WebClient.create("https://api.example.com");
Mono<String> response = webClient.get()
    .uri("/data")
    .retrieve()
    .bodyToMono(String.class);
response.subscribe(System.out::println);

3. RestClient

RestClient एक नया क्लाइंट है जो Spring 6 में पेश किया गया है। यह RestTemplate और WebClient के बीच एक संतुलन प्रदान करता है, और यह सिंक्रोनस और एसिंक्रोनस अनुरोधों को संभालने के लिए उपयुक्त है।

RestClient restClient = RestClient.create();
String response = restClient.get()
    .uri("https://api.example.com/data")
    .retrieve()
    .body(String.class);
System.out.println(response);

निष्कर्ष

Spring REST क्लाइंट्स विभिन्न प्रकार के अनुप्रयोगों में RESTful सेवाओं के साथ बातचीत करने के लिए शक्तिशाली उपकरण प्रदान करते हैं। RestTemplate पुराने अनुप्रयोगों के लिए उपयुक्त है, जबकि WebClient और RestClient आधुनिक, रिएक्टिव अनुप्रयोगों के लिए बेहतर विकल्प हैं।

Spring RESTful क्लाइंट बनाना आसान बनाता है।

  public String getUserInfo(String userId) {
      return restTemplate.getForObject("https://api.example.com/users/" + userId, String.class);
  }

FeignClient

FeignClient एक declarative REST क्लाइंट है जो Spring Cloud में उपलब्ध है। यह RESTful वेब सेवाओं को आसानी से कॉल करने के लिए एक सरल और सुविधाजनक तरीका प्रदान करता है। FeignClient का उपयोग करके, आप इंटरफेस बना सकते हैं और उस इंटरफेस के माध्यम से REST API को कॉल कर सकते हैं। यह कोड को सरल और पठनीय बनाता है।

उदाहरण के लिए:

@FeignClient(name = "example-service", url = "http://example.com")
public interface ExampleServiceClient {
    @GetMapping("/api/resource")
    String getResource();
}

इस उदाहरण में, ExampleServiceClient इंटरफेस http://example.com/api/resource पर GET अनुरोध भेजेगा और प्रतिक्रिया को String के रूप में वापस करेगा।

FeignClient का उपयोग करने के लिए, आपको अपने Spring Boot एप्लिकेशन में spring-cloud-starter-openfeign डिपेंडेंसी जोड़नी होगी।

Feign एक घोषणात्मक वेब सेवा क्लाइंट है।

ईमेल, कार्य और शेड्यूलिंग

ईमेल सहायता

Spring ईमेल भेजने के लिए समर्थन प्रदान करता है।

  public void sendEmail(String to, String subject, String body) {
      SimpleMailMessage message = new SimpleMailMessage();
      message.setTo(to);
      message.setSubject(subject);
      message.setText(body);
      mailSender.send(message);
  }

  public void sendRichEmail(String to, String subject, String body, File attachment) throws MessagingException {
      MimeMessage message = mailSender.createMimeMessage();
      MimeMessageHelper helper = new MimeMessageHelper(message, true);
      helper.setTo(to);
      helper.setSubject(subject);
      helper.setText(body, true);
      helper.addAttachment(attachment.getName(), attachment);
      mailSender.send(message);
  }

टास्क निष्पादन और शेड्यूलिंग

Spring का टास्क एक्ज़ीक्यूशन और शेड्यूलिंग सपोर्ट टास्क को चलाना आसान बनाता है।

स्प्रिंग में टेस्टिंग

Mockito के साथ टेस्टिंग

Mockito टेस्टिंग के लिए एक शक्तिशाली मॉक लाइब्रेरी है।

@InjectMocks
private UserService userService;

यह कोड एक Java क्लास में UserService नामक एक प्राइवेट वेरिएबल को @InjectMocks एनोटेशन के साथ डिक्लेयर करता है। @InjectMocks एनोटेशन का उपयोग मॉक ऑब्जेक्ट्स को टेस्ट क्लास में इंजेक्ट करने के लिए किया जाता है, जो आमतौर पर यूनिट टेस्टिंग के दौरान Mockito फ्रेमवर्क के साथ प्रयोग किया जाता है।

@Test
public void testFindUserById() {
    User user = new User();
    user.setId(1L);
    Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));
}

          User result = userService.findUserById(1L);
          assertNotNull(result);
          assertEquals(1L, result.getId().longValue());
      }
  }

हिंदी अनुवाद:

          User result = userService.findUserById(1L);
          assertNotNull(result);
          assertEquals(1L, result.getId().longValue());
      }
  }

व्याख्या:

MockMvc के साथ टेस्टिंग

MockMvc आपको Spring MVC कंट्रोलर्स का परीक्षण करने की अनुमति देता है।

@Test
public void testGetUser() throws Exception {
    mockMvc.perform(get("/users/1"))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.id").value(1));
}
}

मॉनिटरिंग और प्रबंधन

Spring Boot Actuator

Spring Boot Actuator आपके एप्लिकेशन की निगरानी और प्रबंधन के लिए प्रोडक्शन-रेडी सुविधाएँ प्रदान करता है।

उन्नत विषय

Spring Advice API

Spring Advice API, Spring AOP (Aspect-Oriented Programming) का एक महत्वपूर्ण हिस्सा है। यह आपको क्रॉस-कटिंग कंसर्न्स (cross-cutting concerns) को आपके एप्लिकेशन कोड से अलग करने की अनुमति देता है। Advice, एक ऐसा कोड होता है जो किसी विशिष्ट जॉइन पॉइंट (join point) पर निष्पादित होता है। Spring में, Advice को निम्नलिखित प्रकारों में वर्गीकृत किया जा सकता है:

  1. Before Advice: यह Advice जॉइन पॉइंट से पहले निष्पादित होता है। उदाहरण के लिए, किसी मेथड को कॉल करने से पहले कुछ लॉगिंग करना।

  2. After Returning Advice: यह Advice तब निष्पादित होता है जब जॉइन पॉइंट सफलतापूर्वक समाप्त हो जाता है (यानी, कोई एक्सेप्शन नहीं फेंकता है)।

  3. After Throwing Advice: यह Advice तब निष्पादित होता है जब जॉइन पॉइंट एक एक्सेप्शन फेंकता है।

  4. After (Finally) Advice: यह Advice जॉइन पॉइंट के समाप्त होने के बाद निष्पादित होता है, चाहे वह सामान्य रूप से समाप्त हुआ हो या एक्सेप्शन के कारण।

  5. Around Advice: यह Advice जॉइन पॉइंट के आसपास निष्पादित होता है और यह जॉइन पॉइंट को निष्पादित करने के लिए जिम्मेदार होता है। यह सबसे शक्तिशाली Advice है क्योंकि यह जॉइन पॉइंट के निष्पादन को पूरी तरह से नियंत्रित कर सकता है।

उदाहरण: Before Advice

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("Before method execution: Logging...");
    }
}

इस उदाहरण में, beforeAdvice मेथड com.example.service पैकेज के अंदर किसी भी मेथड के निष्पादन से पहले निष्पादित होगा।

उदाहरण: Around Advice

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class TransactionAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Starting transaction...");
        Object result = joinPoint.proceed();
        System.out.println("Committing transaction...");
        return result;
    }
}

इस उदाहरण में, aroundAdvice मेथड com.example.service पैकेज के अंदर किसी भी मेथड के आसपास निष्पादित होगा और ट्रांजैक्शन को मैनेज करेगा।

Spring Advice API का उपयोग करके, आप अपने एप्लिकेशन में लॉगिंग, ट्रांजैक्शन मैनेजमेंट, सिक्योरिटी, और अन्य क्रॉस-कटिंग कंसर्न्स को आसानी से हैंडल कर सकते हैं।

Spring का Advice API उन्नत AOP (Aspect-Oriented Programming) क्षमताएं प्रदान करता है।

@After("execution(* com.example.service.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
    System.out.println("मेथड के बाद: " + joinPoint.getSignature().getName());
}
}

निष्कर्ष

स्प्रिंग एक शक्तिशाली और बहुमुखी फ्रेमवर्क है जो एंटरप्राइज़-स्तरीय एप्लिकेशन के विकास को सरल बना सकता है। स्प्रिंग बूट, स्प्रिंग डेटा, स्प्रिंग REST, और अन्य स्प्रिंग प्रोजेक्ट्स की सुविधाओं का उपयोग करके, डेवलपर्स मजबूत, स्केलेबल और रखरखाव योग्य एप्लिकेशन को कुशलता से बना सकते हैं। स्प्रिंग बूट एक्ट्यूएटर और टेस्टिंग फ्रेमवर्क जैसे टूल्स के साथ, आप यह सुनिश्चित कर सकते हैं कि आपके एप्लिकेशन प्रोडक्शन-रेडी और अच्छी तरह से टेस्ट किए गए हैं।

Back 2025.01.18 Donate