spring-boot
स्प्रिंग बूट + स्प्रिंग डेटा जेपीए

परिचय

टिप्पणियों

स्प्रिंग बूट और स्प्रिंग डेटा जेपीए एकीकरण मूल उदाहरण है

हम एक ऐसे अनुप्रयोग का निर्माण करने जा रहे हैं जो POJOs को डेटाबेस में संग्रहीत करता है। अनुप्रयोग एक रिलेशनल डेटाबेस में डेटा को संग्रहीत और पुनर्प्राप्त करने के लिए स्प्रिंग डेटा जेपीए का उपयोग करता है। इसकी सबसे सम्मोहक विशेषता रिपॉजिटरी इंटरफ़ेस से रिपॉजिटरी इंप्लीमेंटेशन को स्वचालित रूप से रनटाइम पर बनाने की क्षमता है।

मुख्य वर्ग

package org.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

main() विधि एप्लिकेशन को लॉन्च करने के लिए स्प्रिंग SpringApplication.run() स्प्रिंगएप्लीकेशन.रून main() विधि का उपयोग करती है। कृपया ध्यान दें कि XML की एक भी पंक्ति नहीं है। कोई web.xml फ़ाइल भी नहीं। यह वेब एप्लिकेशन 100% शुद्ध जावा है और आपको किसी प्लंबिंग या इंफ्रास्ट्रक्चर को कॉन्फ़िगर करने की आवश्यकता नहीं है।

इकाई वर्ग

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;

    public Greeting() {
        super();
    }

    public Greeting(String text) {
        super();
        this.text = text;
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

यहां आपके पास दो विशेषताओं, id और text साथ Greeting क्लास है। आपके पास दो कंस्ट्रक्टर भी हैं। डिफ़ॉल्ट निर्माणकर्ता केवल JPA के लिए मौजूद है। आप इसे सीधे उपयोग नहीं करेंगे, इसलिए इसे protected किया जा सकता protected । अन्य निर्माता वह है जिसका उपयोग आप डेटाबेस को सहेजने के लिए Greeting उदाहरण बनाने के लिए करेंगे।

Greeting वर्ग को @Entity साथ एनोटेट किया @Entity , यह दर्शाता है कि यह एक जेपीए इकाई है। @Table एनोटेशन की कमी के लिए, यह माना जाता है कि इस इकाई को 'ग्रीटिंग' नामक तालिका में मैप किया जाएगा।

ग्रीटिंग की id संपत्ति @Id साथ एनोटेट की @Id ताकि JPA इसे ऑब्जेक्ट की आईडी के रूप में पहचान ले। id प्रॉपर्टी को यह @GeneratedValue लिए @GeneratedValue साथ भी एनोटेट किया गया है कि आईडी अपने आप जेनरेट होनी चाहिए।

अन्य संपत्ति, text किसी का ध्यान नहीं छोड़ा गया है। यह माना जाता है कि यह एक स्तंभ पर मैप किया जाएगा जो संपत्ति के समान नाम को साझा करता है।

क्षणिक गुण

उपरोक्त के समान एक इकाई वर्ग में, हमारे पास ऐसे गुण हो सकते हैं जिन्हें हम डेटाबेस में बनाए रखना नहीं चाहते हैं या हमारे डेटाबेस में कॉलम के रूप में बनाए जा सकते हैं, क्योंकि हम उन्हें रनटाइम पर सेट करना चाहते हैं और उनका उपयोग हमारे आवेदन में कर सकते हैं। इसलिए हम उस संपत्ति को एनोटेशन एनोटेशन के साथ ले सकते हैं।

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;
    @Transient
    private String textInSomeLanguage;
    
    public Greeting() {
        super();
    }
 
    public Greeting(String text) {
        super();
        this.text = text;
        this.textInSomeLanguage = getTextTranslationInSpecifiedLanguage(text);
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

यहां आपके पास एक ही ग्रीटिंग क्लास है जिसमें अब एक क्षणिक संपत्ति textInSomeLanguage जिसे प्रारंभ किया जा सकता है और रनटाइम पर उपयोग किया जा सकता है और डेटाबेस में जारी नहीं रहेगा।

डीएओ क्लास

package org.springboot.repository;

import org.springboot.model.Greeting;
import org.springframework.data.repository.CrudRepository;

public interface GreetingRepository extends CrudRepository<Greeting, Long> {

    List<Greeting> findByText(String text);
}

GreetingRepository CrudRepository इंटरफ़ेस का विस्तार करता है। Greeting और Long साथ काम करने वाली इकाई और आईडी का प्रकार, CrudRepository पर जेनेरिक मापदंडों में निर्दिष्ट है। विस्तार करके CrudRepository , GreetingRepository के साथ काम करने के लिए विरासत में मिली कई तरीके Greeting हठ, बचत, हटाने, और खोजने के लिए उपाय अपना सकते हैं Greeting संस्थाओं।
CrudRepository , PagingAndSortingRepository , JpaRepository की तुलना के लिए इस चर्चा को देखें।

स्प्रिंग डेटा JPA आपको केवल उनके विधि हस्ताक्षर की घोषणा करके अन्य क्वेरी विधियों को परिभाषित करने की अनुमति देता है। GreetingRepository findByText() के मामले में, यह एक findByText() विधि के साथ दिखाया गया है।

एक सामान्य जावा एप्लिकेशन में, आप एक वर्ग लिखने की उम्मीद करेंगे जो GreetingRepository लागू करता है। लेकिन यही वह है जो स्प्रिंग डेटा JPA को इतना शक्तिशाली बनाता है: आपको रिपॉजिटरी इंटरफ़ेस का कार्यान्वयन लिखना नहीं है। जब आप एप्लिकेशन चलाते हैं तो स्प्रिंग डेटा जेपीए मक्खी पर एक कार्यान्वयन बनाता है।

सेवा वर्ग

package org.springboot.service;

import java.util.Collection
import org.springboot.model.Greeting;

public interface GreetingService {

    Collection<Greeting> findAll();
    Greeting findOne(Long id);
    Greeting create(Greeting greeting);
    Greeting update(Greeting greeting);
    void delete(Long id);

}

सेवा बीन

package org.springboot.service;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.repository.GreetingRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingServiceBean implements GreetingService {

    @Autowired
    private GreetingRepository greetingRepository;

    @Override
    public Collection<Greeting> findAll() {
        Collection<Greeting> greetings = greetingRepository.findAll();
        return greetings;
    }

    @Override
    public Greeting findOne(Long id) {
        Greeting greeting = greetingRepository.findOne(id);
        return greeting;
    }

    @Override
    public Greeting create(Greeting greeting) {
        if (greeting.getId() != null) {
            //cannot create Greeting with specified Id value
            return null;
        }
        Greeting savedGreeting = greetingRepository.save(greeting);
        return savedGreeting;
    }

    @Override
    public Greeting update(Greeting greeting) {
        Greeting greetingPersisted = findOne(greeting.getId());
        if (greetingPersisted == null) {
            //cannot find Greeting with specified Id value
            return null;
        }
        Greeting updatedGreeting = greetingRepository.save(greeting);
        return updatedGreeting;
    }

    @Override
    public void delete(Long id) {
         greetingRepository.delete(id);
    }

}

नियंत्रक वर्ग

package org.springboot.web.api;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/api")
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    // GET [method = RequestMethod.GET] is a default method for any request. 
    // So we do not need to mention explicitly

    @RequestMapping(value = "/greetings", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Collection<Greeting>> getGreetings() {
        Collection<Greeting> greetings = greetingService.findAll();        
        return new ResponseEntity<Collection<Greeting>>(greetings, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> getGreeting(@PathVariable("id") Long id) {
        Greeting greeting = greetingService.findOne(id);
        if(greeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Greeting>(greeting, HttpStatus.OK);
    }
    
    @RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> createGreeting(@RequestBody Greeting greeting) {
        Greeting savedGreeting = greetingService.create(greeting);
        return new ResponseEntity<Greeting>(savedGreeting, HttpStatus.CREATED);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> updateGreeting(@PathVariable("id") Long id, @RequestBody Greeting greeting) {
        Greeting updatedGreeting = null;
        if (greeting != null && id == greeting.getId()) {
            updatedGreeting = greetingService.update(greeting); 
        }
        if(updatedGreeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<Greeting>(updatedGreeting, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Greeting> deleteGreeting(@PathVariable("id") Long id) {
        greetingService.delete(id);
        return new ResponseEntity<Greeting>(HttpStatus.NO_CONTENT);
    }

}

अनुप्रयोग गुण MySQL डेटाबेस के लिए फ़ाइल

#mysql config
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=Welcome@123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update

spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultNamingStrategy

#initialization
spring.datasource.schema=classpath:/data/schema.sql

SQL फ़ाइल

drop table if exists greeting;
create table greeting (
    id bigint not null auto_increment, 
    text varchar(100) not null, 
    primary key(id)
);

pom.xml फ़ाइल

<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>org</groupId>
<artifactId>springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.1.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

एक निष्पादन योग्य JAR का निर्माण

आप मावेन के साथ कमांड लाइन से एप्लिकेशन चला सकते हैं। या आप एक एकल निष्पादन योग्य JAR फ़ाइल बना सकते हैं जिसमें सभी आवश्यक निर्भरताएँ, कक्षाएं और संसाधन शामिल हैं, और उसे चलाएं। इससे जहाज को विकसित करना, संस्करण बनाना और सेवा को विकास के जीवन चक्र में, विभिन्न वातावरणों में, और उसके बाद एक सेवा के रूप में तैनात करना आसान हो जाता है।

अनुप्रयोग का उपयोग करके ./mvnw spring-boot:run । या आप ./mvnw clean package साथ JAR फाइल बना सकते हैं। तब आप JAR फ़ाइल चला सकते हैं:

java -jar target/springboot-0.0.1-SNAPSHOT.jar