Arbeiten mit SQL-Datenbanken und Spring Boot

In diesem Tutorial erkläre ich Ihnen, wie Sie SQL-Datenbanken und Spring Boot zusammen verwenden. Wenn Sie in Spring Framework-Projekten arbeiten, sollten Sie sehr gut wissen, wie Sie SQL-Datenbanken und Spring Boot zum Persistieren von Anwendungsdaten verwenden.

SQL-Datenbanken sind ein integraler Bestandteil jeder zu entwickelnden Anwendung. Sie helfen bei der Beibehaltung von Anwendungsdaten. SQL-Datenbanken bieten erweiterte Unterstützung für die Abfrage von Daten mithilfe der Structured Query Language (SQL). Spring Boot bietet hervorragende Unterstützung für die Interaktion mit SQL-Datenbanken mit minimalen oder keinen XML-Konfigurationen. In diesem Artikel werden wir uns Folgendes ansehen:

  • Konfigurieren der Speicherdatenbank und Abrufen von Daten mithilfe von JdbcTemplate
  • Konfigurieren der Produktionsdatenbank und Abrufen von Daten mithilfe von JdbcTemplate
  • Verwendung von JPA und Spring Data
  • In-Memory-Datenbank mit JdbcTemplate

    Der schnellste Weg, etwas zu testen, ist die Verwendung einer eingebetteten Datenbank. Dies erleichtert den Einstieg in die Anwendung ohne großen Aufwand bei der Installation der Datenbank. Sehen wir uns an, wie wir die eingebettete Datenbank verwenden und wie wir das Schema initialisieren können, das in der eingebetteten Datenbank erstellt werden muss. Fügen wir zunächst die Abhängigkeiten hinzu pom.xml:

    • Lesen Sie: Apache Maven für Anfänger
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <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>
    
    • In die oben genannten Abhängigkeiten haben wir die JDBC-Abhängigkeit aufgenommen – diese gibt uns JdbcTemplate und andere JDBC-Bibliotheken, die org.hsqldb-Abhängigkeit fügt eingebettetes hsqldb hinzu.
    • Wir müssen keine Konfigurationen hinzufügen, um eine Verbindung zu dieser eingebetteten Datenbank herzustellen, alles wird von Springboot verwaltet.
    • Diese eingebetteten Datenbanken befinden sich im Arbeitsspeicher und jedes Mal, wenn die Anwendung herunterfährt, werden das Schema und die Daten gelöscht. Eine Möglichkeit, Schema und Daten im In-Memory zu belassen, besteht darin, ihn während des Anwendungsstarts zu füllen. Dafür sorgt Springboot.
    • Einer der Ansätze ist das Erstellen schema.sql Und data.sql Dateien im Klassenpfad der Anwendung.
    • Spring JDBC verwendet diese SQL-Dateien, um ein Schema zu erstellen und Daten in das Schema einzufügen. Es sind noch weitere Techniken aufgeführt Hier.

    Man kann mehrere schema.sql- und data.sql-Dateien erstellen, eine für jede Datenbankplattform. Wir können also schema-hsqldb.sql, data-hsqldb.sql, schema-mysql.sql und so weiter haben. Und die auszuwählende Datei wird durch den der Eigenschaft zugewiesenen Wert bestimmt spring.datasource.platform. In diesem Beitrag erstellen wir eine schema-hsqldb.sql-Datei mit folgendem Inhalt:

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

    Als nächstes geht es ans Erstellen application-local.properties Datei zum Definieren der Werte für Anwendungseigenschaften. Bitte lesen Sie unsere vorherigen Artikel über externe Konfigurationen. Nachfolgend finden Sie den Inhalt für application-local.properties:

    spring.datasource.platform=hsqldb
    

    Als nächstes erstellen Sie die Person Modellklasse:

    package net.javabeat;
    
    public class Person {
      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();
      }
    
    }
    

    Als Nächstes erstellen Sie eine Serviceklasse PersonService was nutzt JdbcTemplate um Daten einzufügen und Daten aus hsqldb abzurufen. Es gibt zwei Methoden in der Serviceklasse: addPerson Und getAllPerson. addPerson fügt eine neue Zeile hinzu person Tisch und getAllPerson ruft alle Zeilen in der ab person Tisch. Unten ist die PersonService Klassendefinition:

    package net.javabeat;
    
    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;
    
    @Service
    public class PersonService {
    
      @Autowired
      private JdbcTemplate jdbcTemplate;
    
      public int addPerson(Person person){
        String sql = "INSERT INTO person(first_name, last_name, age, place) VALUES(?,?,?,?)";
        return jdbcTemplate.update(sql, person.getFirstName(),
            person.getLastName(), person.getAge(), person.getPlace());
      }
    
      public List<Person> getAllPerson(){
        return jdbcTemplate.query("SELECT * FROM person", new RowMapper<Person>(){
    
          public Person mapRow(ResultSet rs, int arg1) throws SQLException {
            Person p = new Person();
            p.setAge(rs.getInt("age"));
            p.setFirstName(rs.getString("first_name"));
            p.setLastName(rs.getString("last_name"));
            p.setPlace(rs.getString("place"));
            return p;
          }
    
        });
      }
    }
    

    Erstellung von DataSource Beispiel, JdbcTemplate Die Instanz wird vollständig von Spring Boot übernommen. Als nächstes wird die Hauptklasse erstellt, die das startet SpringApplication. Nachfolgend finden Sie die Definition von SpringbootSqlDemo Klasse:

    package net.javabeat;
    
    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;
    
    @SpringBootApplication
    public class SpringbootSqlDemo implements CommandLineRunner{
    
      Logger logger = LoggerFactory.getLogger(SpringbootSqlDemo.class);
    
      @Autowired
      PersonService personService;
    
      public void run(String... args) {
        Person person = new Person();
        person.setFirstName("FName");
        person.setLastName("LName");
        person.setAge(20);
        person.setPlace("Place");
    
        if ( personService.addPerson(person) > 0){
          logger.info("Person saved successfully");
        }
    
        for(Person p : personService.getAllPerson()){
          logger.info(p.toString());
        }
    
      }
    
      public static void main(String[] args) {
        SpringApplication.run(SpringbootSqlDemo.class, args);
      }
    
    }
    

    Die obige Klasse implementiert CommandLineRunner Schnittstelle, sodass sie ausgeführt werden kann, sobald der Spring Boot-Anwendungskontext vollständig initialisiert wurde. Dies ermöglicht die Erstellung von Instanzen von DataSource, JdbcTemplate, PersonService und anderen Beans.

    Der run(String... args) Die Methode fügt zunächst eine Zeile in die Personentabelle ein, ruft dann alle Zeilen in der Personentabelle ab und protokolliert sie mit dem Logger. Sobald wir die Anwendung ausführen, können wir die eingefügten Zeilen sehen. Mit all diesen neuen Dateien sieht die Projektstruktur wie folgt aus:
    Spring Boot SQL-Datenbanken

    Lassen Sie uns die Anwendung mit dem folgenden Befehl ausführen: mvn spring-boot:run -Dspring.profiles.active=local. Unten sehen Sie den Ausgabeausschnitt, der nach der Ausführung der Anwendung erhalten wird:

    ...
    2015-08-20 19:50:00.704  INFO 5572 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Person saved successfully
    2015-08-20 19:50:00.719  INFO 5572 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    ...
    

    Sie können feststellen, dass eine neue Zeile hinzugefügt wurde person Tabelle und auch alle in der Tabelle verfügbaren Zeilen wurden gedruckt.

    Produktionsdatenbankkonfigurationen mit JdbcTemplate

    In-Memory-Datenbanken unterliegen vielen Einschränkungen und sind in den frühen Phasen der Anwendung und auch in lokalen Umgebungen nützlich. Mit fortschreitender Anwendungsentwicklung benötigen wir Daten, die auch nach Anwendungsende vorhanden sind.

    In solchen Fällen konfigurieren wir eine installierte Datenbank. Zur Veranschaulichung dieses Beispiels verwenden wir PostgreSql. Man kann PostgreSql herunterladen und installieren Hier. Lassen Sie uns ein neues Profil erstellen und es benennen stage. Dieses Profil nutzt PostgreSql. Dazu müssen wir application-stage.properties wie unten gezeigt erstellen:

    spring.database.driverClassName=org.postgresql.Driver
    spring.datasource.url=jdbc:postgresql://localhost:5433/postgres
    spring.datasource.username=postgres
    spring.datasource.password=postgres
    

    Oben sind die Verbindungs-URL, der Benutzername und das Passwort für die Verbindung zur Postgres-Instanz aufgeführt. Wir müssten das erstellen person Tabelle in der Postgres-Instanz.

    Wir werden auch pom.xml aktualisieren, um die hsqldb-Abhängigkeit auskommentieren und stattdessen eine Abhängigkeit zum Postgres-Treiber hinzufügen, wie unten gezeigt:

    <!-- <dependency>
      <groupId>org.hsqldb</groupId>
      <artifactId>hsqldb</artifactId>
      <scope>runtime</scope>
    </dependency> -->
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>9.4-1201-jdbc41</version>
    </dependency>
    

    Lassen Sie uns nun die Anwendung mit dem folgenden Befehl ausführen: mvn spring-boot:run -Dspring.profiles.active=stage. Sie können die gleiche Ausgabe sehen, die Sie beim obigen Lauf gesehen haben:

    2015-08-20 20:06:23.829  INFO 3676 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Person saved successfully
    2015-08-20 20:06:23.845  INFO 3676 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    

    Wenn Sie es jedoch in diesem Fall mehrmals ausführen, werden mehrere Einträge im angezeigt person Tabelle wie unten gezeigt:

    2015-08-20 20:54:21.914  INFO 6924 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Person saved successfully
    2015-08-20 20:54:21.945  INFO 6924 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-20 20:54:21.945  INFO 6924 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    

    Dies liegt daran, dass die Daten in diesem Fall persistent sind, im Gegensatz zu hsqldb, bei dem es sich um eine speicherinterne Datenbank handelt.

    JPA und Spring Data mit Spring Boot

    In den obigen Abschnitten haben wir die Interaktion mit der Datenbank mithilfe von JdbcTemplate gesehen. In diesem Abschnitt werden wir sehen, wie dasselbe mit der Java Persistance API erreicht werden kann. Spring Data bietet einen hervorragenden Mechanismus zum Erreichen der Persistenz mithilfe von JPA. Der erste Schritt ist das Update pom.xml um die Abhängigkeit von JPA wie unten gezeigt hinzuzufügen:

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    

    Als nächstes werden wir eine neue Spalte in der Personentabelle einführen und außerdem eine Sequenz erstellen, um den Wert in der neuen Spalte automatisch zu erhöhen und diese Sequenz an die neu erstellte Spalte zu binden. Die folgenden SQL-Befehle helfen uns dabei:

    CREATE SEQUENCE person_id_seq START WITH 1 INCREMENT BY 1;
    ALTER TABLE person ADD COLUMN id numeric DEFAULT nextval('person_id_seq');
    ALTER SEQUENCE person_id_seq OWNED BY person.id;
    

    Als Nächstes erstellen Sie eine Entitätsklasse, die der zugrunde liegenden Tabelle zugeordnet ist. Lassen Sie uns PersonEntity wie unten gezeigt erstellen:

    package net.javabeat;
    
    import java.io.Serializable;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "person")
    public class PersonEntity implements Serializable{
    
      private static final long serialVersionUID = -1801714432822866390L;
    
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private long id;
    
      @Column(name="first_name", nullable = false)
      private String firstName;
    
      @Column(name="last_name", nullable = false)
      private String lastName;
    
      private int age;
    
      private String place;
    
      protected PersonEntity(){
    
      }
    
      public PersonEntity(String firstName, String lastName, int age, String place){
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.place = place;
      }
    
      public String toString(){
        StringBuilder builder = new StringBuilder();
        builder.append(this.getId()).append(", ")
          .append(this.getFirstName()).append(", ")
          .append(this.getLastName()).append(", ")
          .append(this.getPlace()).append(", ")
          .append(this.getAge());
    
        return builder.toString();
      }
    
      public long getId() {
        return id;
      }
    
      public void setId(long id) {
        this.id = id;
      }
    
      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;
      }
    }
    

    Als Nächstes müssen wir eine Repository-Klasse erstellen, die uns grundlegende APIs für die Interaktion mit der Datenbank bereitstellt und außerdem die Möglichkeit bietet, neue APIs für die Interaktion mit der Datenbank hinzuzufügen. Wir werden die verwenden CrudRepository bereitgestellt durch Frühlingsdaten. Es stellt uns APIs zur Verfügung, um CRUD-Operationen und einige Suchoperationen wie findAll, findOne und count durchzuführen. Lassen Sie uns die PersonRepository-Schnittstelle wie unten gezeigt erstellen:

    package net.javabeat;
    
    import org.springframework.data.repository.CrudRepository;
    
    public interface PersonRepository extends CrudRepository<PersonEntity, Long>{
    }
    

    Als nächstes folgt das Update SpringbootSqlDemo Klasse mit Code für den Zugriff auf die Datenbank mithilfe von PersonRepository und PersonEntity. Wir behalten auch den JdbcTemplate-Code bei. Fügen Sie den folgenden Code hinzu run Methode der SpringbootSqlDemo Klasse:

    logger.info("Using JPA for insert and find");
    PersonEntity personEntity = new PersonEntity("fName2", "lName2", 24, "Bangalore");
    personEntity = personRepository.save(personEntity);
    logger.info("Person with ID: " + personEntity.getId() + " saved successfully");
    
    for ( PersonEntity pEntity : personRepository.findAll()){
      logger.info(pEntity.toString());
    }
    

    Die Struktur des Anwendungsprojekts sieht in etwa so aus:
    Spring Boot Spring Data JPALassen Sie uns die Anwendung mit dem folgenden Befehl ausführen: mvn spring-boot:run -Dspring.profiles.active=stage. Sie können die von JdbcTemplate eingefügten und gelesenen Daten sowie die mit JPA eingefügten und gelesenen Daten wie unten dargestellt erkennen:

    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Person saved successfully
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : fName2, lName2, Bangalore, 24
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : FName, LName, Place, 20
    2015-08-21 06:18:59.054  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Using JPA for insert and find
    2015-08-21 06:18:59.101  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : Person with ID: 9 saved successfully
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 1, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 2, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 3, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 4, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 5, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 6, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 7, fName2, lName2, Bangalore, 24
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 8, FName, LName, Place, 20
    2015-08-21 06:18:59.272  INFO 13544 --- [tSqlDemo.main()] net.javabeat.SpringbootSqlDemo           : 9, fName2, lName2, Bangalore, 24
    

    Durch die Verwendung von JPA wird viel Boiler-Plate-Code reduziert. Man kann sogar Methoden in der Repository-Klasse erstellen und sie mit dem SQL annotieren, das wir ausführen möchten. Der in diesem Artikel verwendete Code ist im Github-Repository von JavaBeat verfügbar Hier. (Auch ursprünglich in Sanaullas Repository geschrieben Hier).

    In diesem Artikel haben wir gesehen, wie wir von In-Memory-Datenbanken zu installierten Datenbanken übergegangen sind und haben auch gesehen, wie wir JdbcTemplate und JPA verwenden können, um mit der Datenbank zu interagieren. Wir mussten keinerlei XML-Konfiguration schreiben und alles wurde durch die von Springboot bereitgestellte automatische Konfiguration verwaltet. Insgesamt hätten Sie eine gute Vorstellung davon bekommen, wie Sie SQL-Datenbanken und Spring Boot gemeinsam für die Beibehaltung der Anwendungsdaten nutzen können.

    Wie geht es Ihnen bei Ihren Projekten? Bitte teilen Sie uns Ihre Erfahrungen in unserem Kommentarbereich mit.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen