Spring Boot - ჩაშენებულ მონაცემთა ბაზასთან მუშაობა


მონაცემთა ბაზა ქმნის ნებისმიერი პროგრამის განუყოფელ ნაწილს. იგი გამოიყენება მონაცემთა წაკითხვისა და შენარჩუნებისთვის.

[vc_row] [vc_column width = ”2/3] [td_block_text_with_title custom_title =” რა არის ჩანერგილი DB? ”] [/ td_block_text_with_title] [/ vc_column] [/ vc_row]

  • ტიპიური მონაცემთა ბაზა მოითხოვს უამრავ დაყენებას. მაგალითად, იმისათვის, რომ გამოიყენოთ Oracle ან MYSQL პროგრამაში, უნდა გააკეთოთ შემდეგი ნაბიჯები:
    • დააინსტალირეთ DB.
    • სქემის და ცხრილების დაყენება
    • შეავსეთ მონაცემები
    • Datasource- ის გამოყენება DB- სთან და ბევრ პერსონალურ კოდთან დაკავშირების მიზნით
  • განვიხილოთ სიტუაცია, როდესაც გვსურს სწრაფი POC გავაკეთოთ განვითარების პროცესში. ასეთ სცენარებში ტრადიციული DB– ს გამოყენება ბევრ დამატებით ხარჯებს მოიცავს და, როგორც წესი, არ არის რეკომენდებული. აქ შეიქმნება ჩანერგილი (მეხსიერებაში) მონაცემთა ბაზის კონცეფცია.
  • ჩანერგილი მონაცემთა ბაზის კონცეფცია ძალიან სასარგებლოა განვითარების ეტაპზე, რადგან ისინი მსუბუქი, სწრაფი, სწრაფი დაწყების დროა, აუმჯობესებს ტესტირებად, კონფიგურაციის მარტივად. ის საშუალებას აძლევს დეველოპერს, უფრო მეტი ყურადღება გაამახვილოს განვითარებაზე, ვიდრე ყურადღება გაამახვილოს დეტალებზე, როგორიცაა მონაცემთა წყაროს კონფიგურაცია მონაცემთა ბაზაში, ან დროის დაკარგვა მძიმე მონაცემთა ბაზის დასაწყებად, რამდენიმე კოდის შესამოწმებლად.
  • ჩანერგილი (ან) მეხსიერების მონაცემთა ბაზის რამდენიმე მაგალითია:
    • HSQLDB
    • H2
    • დერბი

Ჩაინიშნე :

  • მეხსიერების მონაცემთა ბაზა იქმნება აპლიკაციის გაშვებისას და განადგურებულია აპლიკაციის შეწყვეტისას. შესაბამისად, მონაცემები იკარგება სერვერის გადატვირთვის შემთხვევაში. ამრიგად, ეს არ არის იდეალური ვარიანტი საწარმოო გარემოში.
  • ჩაშენებული DB ვარიანტი ხელმისაწვდომია გაზაფხულის 3.0-დან
  • შეცვლა Spring Boot საწყისი Embedded DB (როგორიცაა H2 / HSQL) to ტრადიციული DB (Oracle, MySQL) მარტივია, გარეშე ბევრი კონფიგურაცია.

ამ სახელმძღვანელოში ჩვენ ვნახავთ, თუ როგორ შეგვიძლია Spring Boot- ის ინტეგრირება მონაცემთა ბაზაში, როგორიცაა HSQLDB.

Spring გთავაზობთ სასიამოვნო აბსტრაქციას JDBC API– ს გამოყენებით Jdbc თარგი ასევე უზრუნველყოფს გარიგების მართვის დიდ შესაძლებლობებს ანოტაციაზე დაფუძნებული მიდგომის გამოყენებით.

HSQLDB– ის გამოყენება JDBCTemplate– ით

ამ მაგალითში, ჩვენ ვქმნით მარტივ პროგრამას, რომელიც ზოგავს მომხმარებლის დეტალებს (სახელი, გვარი, ასაკი და ადგილი) HSQLDB– ში და ბეჭდავს მას იგივე კონსოლში.

Maven დამოკიდებულებების დამატება

  • დაამატეთ შემდეგი დამოკიდებულებები maven:
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
  <groupId>org.hsqldb</groupId>
  <artifactId>hsqldb</artifactId>
  <scope>runtime</scope>
</dependency>
  • გაითვალისწინეთ, რომ ზემოთ მოცემულ დამოკიდებულებებში:
    • გაზაფხული-ჩატვირთვის-შემქმნელი-jdbc : ამატებს საჭირო JdbcTemplate და სხვა JDBC ბიბლიოთეკებს.
    • ჰსკლბდ : ამატებს HSQLDB ბიბლიოთეკებს.

სქემის / პოპულაციური მონაცემების შექმნა

როგორც უკვე ვიცით, რომ ჩანართები / სქემა, რომლებიც მოცემულია ჩანერგილ DB– ში, დაიკარგება / წაიშლება განაცხადის ხელახლა დაწყების შემდეგ. სქემის / მონაცემების ინიციალიზაციის ერთ – ერთი გზაა SQL ფაილების გამოყენება კლასში, განაცხადის გაშვების დროს.

ჩვენ შეგვიძლია შევქმნათ მრავალი სქემა / მონაცემები SQL ფაილები თითოეულისთვის მონაცემთა ბაზის ჩარჩოსთვის და განათავსოთ იგი განაცხადის კლასში.

მაგალითად:

  • HSQLDB– სთვის ფაილის სახელები იქნება ამ ფორმატში:
    • სქემა- hsqldb.sql
    • data-hsqldb.sql
  • MYSQL- სთვის ფაილის სახელები იქნება ამ ფორმატში:
    • სქემა-mysql.sql
    • data-mysql.sql

ასაღებად ფაილს წყვეტს ქონებაზე მინიჭებული მნიშვნელობა spring.datasource.platform. ამ პოსტში, ჩვენ ვაპირებთ შექმნას სქემა- hsqldb.sql შეიტანეთ ფაილი შემდეგი შინაარსით და განათავსეთ ქვემოთ src/main/resources საქაღალდე.

CREATE TABLE person(
  first_name  VARCHAR(150),
  last_name   VARCHAR(150),
  age         INTEGER,
  place       VARCHAR(100)
);

შემდეგი ნაბიჯი არის თვისების დამატება spring.datasource.platform in პროგრამა.

spring.datasource.platform=hsqldb 

სამოდელო კლასის შექმნა

  • შექმნა დამკვეთი მოდელის კლასი, როგორც ნაჩვენებია ქვემოთ:
package com.example.demo.model;
public class Customer {
    private String firstName;
    private String lastName;
    private int age;
    private String place;
    public String getFirstName() {
      return firstName;
    }
    public void setFirstName(String firstName) {
      this.firstName = firstName;
    }
    public String getLastName() {
      return lastName;
    }
    public void setLastName(String lastName) {
      this.lastName = lastName;
    }
    public int getAge() {
      return age;
    }
    public void setAge(int age) {
      this.age = age;
    }
    public String getPlace() {
      return place;
    }
    public void setPlace(String place) {
      this.place = place;
    }
    public String toString(){
      StringBuilder builder = new StringBuilder();
      builder.append(this.getFirstName())
        .append(", ")
        .append(this.getLastName())
        .append(", ")
        .append(this.getPlace())
        .append(", ")
        .append(this.getAge());
      return builder.toString();
    }
  }

მომსახურების კლასის შექმნა

შემდეგი ნაბიჯი არის მომხმარებელთა მომსახურების კლასის შექმნა, რომელიც იყენებს JdbcTemplate- ს მომხმარებლის დეტალების შენახვასა თუ აღსადგენად. მას აქვს ორი მეთოდი, როგორც ნაჩვენებია ქვემოთ: addCustomer () და getAllCustomers ().

package com.example.demo.service;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import com.example.demo.model.Customer;
@Service
public class CustomerService {
  @Autowired
  private JdbcTemplate jdbcTemplate;
  public int addCustomer(Customer customer) {
    String sql = "INSERT INTO customer(first_name, last_name, age, place) VALUES(?,?,?,?)";
    return jdbcTemplate.update(sql, customer.getFirstName(), customer.getLastName(), customer.getAge(),
        customer.getPlace());
  }
  public List<Customer> getAllCustomers() {
    return jdbcTemplate.query("SELECT * FROM customer", new RowMapper<Customer>() {
      public Customer mapRow(ResultSet rs, int arg1) throws SQLException {
        Customer c = new Customer();
        c.setAge(rs.getInt("age"));
        c.setFirstName(rs.getString("first_name"));
        c.setLastName(rs.getString("last_name"));
        c.setPlace(rs.getString("place"));
        return c;
      }
    });
  }
}

ძირითადი კლასის შექმნა

შემდეგი ნაბიჯი არის მთავარი კლასის შექმნა, რომელიც იწყებს SpringBootApplication. ქვემოთ მოცემულია განმარტება SpringbootSqlDemo კლასი:

package com.example.demo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.example.demo.model.Customer;
import com.example.demo.service.CustomerService;
@SpringBootApplication
public class SpringbootSqlDemo implements CommandLineRunner{
  Logger logger = LoggerFactory.getLogger(SpringbootSqlDemo.class);
  @Autowired
  CustomerService customerService;
  public void run(String... args) {
    Customer customer = new Customer();
    customer.setFirstName("Rahul");
    customer.setLastName("Gupta");
    customer.setAge(20);
    customer.setPlace("Bengaluru");
    if (customerService.addCustomer(customer) > 0){
      logger.info("****Customer added successfully****");
    }
    for(Customer p : customerService.getAllCustomers()){
      logger.info(p.toString());
    }
  }
  public static void main(String[] args) {
    SpringApplication.run(SpringbootSqlDemo.class, args);
  }
}

ზემოთ კლასში, როდესაც პროგრამა იწყებს და გაშვება () მეთოდს ეწოდება, იგი ჩასვამს მომხმარებელთა ერთ ჩანაწერს და შემდეგ ბეჭდავს ყველა ჩანაწერს „მომხმარებელს”მაგიდა.

განაცხადის საბოლოო სტრუქტურა გამოიყურება ქვემოთ:

განაცხადის პაკეტის სტრუქტურა

მოდით აწარმოოთ პროგრამა და დავაკვირდეთ კონსოლის გამომუშავებას:

კონსოლის გამომავალი

თქვენ შეამჩნევთ, რომ დაემატა ახალი მწკრივი customer დაბეჭდილია ცხრილი და ასევე ცხრილში არსებული ყველა სტრიქონი.

შეგიძლიათ ჩამოტვირთოთ კოდის კოდი ქვემოთ მოცემული ბმულიდან:

დასკვნა

ამ სახელმძღვანელოში ჩვენ ვისწავლეთ, თუ როგორ უნდა გავაერთიანოთ გაზაფხულის ჩატვირთვის პროგრამა ჩადგმულ მონაცემთა ბაზასთან HSQLDB. შემდეგ სახელმძღვანელოში ჩვენ ვნახავთ თუ როგორ უნდა ვიმუშაოთ ტრადიციულ DB– თან, როგორიცაა Oracle, MySQL და ა.შ..

ლიტერატურა

შეგიძლიათ გაეცნოთ შემდეგ ბმულებს საგაზაფხულო ჩატვირთვის დოკუმენტაციიდან:

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-embedded-database-support