Detaillierte Erläuterung des Spring Boot JPA-Zugriffs auf MySQL-Beispielcode (Bild und Text)

In diesem Artikel wird hauptsächlich das Spring Boot JPA-Zugriffsbeispiel Mysql vorgestellt. Der Herausgeber findet es recht gut, daher werde ich es jetzt mit Ihnen teilen und als Referenz verwenden. Folgen wir dem Editor und werfen wir einen Blick darauf.

Der vorherige Artikel zeigte, wie man ein Spring Boot-Projekt über Maven erstellt, die Anwendung durch Verweis auf das Webmodul startet und den einfachen Zugriff auf die Webanwendung durchführt und Portmodifikation auf dieser Basis, der folgende Code und Beispiele (dieser Anwendungsfall wurde rein manuell getestet und bestanden, also machen Sie sich darüber keine Sorgen).

Ändern Sie den Standardport

Fügen Sie application.properties unter srcmainresources mit dem folgenden Inhalt hinzu

server.port=8888

ProjektVerzeichnisstruktur

Starten Sie die Anwendung und das Protokoll zeigt:

Der Port wurde von der Standardeinstellung 8080 auf 8888 geändert

JPA Access MySQL-Datenbank

1.

  <!-- Spring Boot JPA -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>RELEASE</version>
  </dependency>
  <!-- MYSQL -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>

zu POM hinzufügen 2. application.properties unter srctestresources mit dem folgenden Inhalt hinzufügen (für formale Anwendungen, fügen Sie bitte die Konfiguration zu srcmainresources hinzu (Down application.properties):

server.port=8888
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop

1. create: generiert eine Tabelle basierend auf Ihrer model-Klasse, aber die Die vorherige Tabelle wird bei jeder Ausführung gelöscht. Generieren Sie die Tabelle neu, auch wenn es zweimal keine Änderung gibt (in der Produktion deaktiviert, Sie werden weinen, wenn Sie sie versehentlich verwenden ...)

2. create-drop: Generieren Sie die Tabelle gemäß der Modellklasse, aber die sessionFactory ist Beim Schließen wird die Tabelle automatisch gelöscht (für die Produktion deaktiviert)

3. Update: Am häufigsten Das verwendete Attribut generiert auch eine Tabelle basierend auf der Modellklasse. Auch wenn sich die Tabellenstruktur ändert, werden die Zeilen in der Tabelle weiterhin gelöscht Im Vergleich zur Tabelle in der Datenbank wird keine neue Tabelle erstellt, sondern neue Werte eingefügt

4. 
   3. Erstellen Sie eine neue Entität

srcmainjavacomentityUser.java

Neuen Datenzugriff erstellen

Interface

(JPA)

package com.entity;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
@Entity
@Table(name="t_user")
public class User implements Serializable {
private static final long serialVersionUID = -3258839839160856613L;
  @Id
  @GeneratedValue
  private Long id;

  private String name;

  private String moblie;



  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

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

  public String getMoblie() {
    return moblie;
  }

  public void setMoblie(String moblie) {
    this.moblie = moblie;
  }
}

srcmainjavacomdaoUserRepository .java

Wie aus dem Quellcode hervorgeht, hat JpaRepository die Methoden Speichern (Aktualisieren und Speichern), Löschen, GetOne, FindAll und andere implementiert, sodass die Schnittstelle für den Betrieb grundlegender Daten nicht verwendet werden kann. Wenn eine Neudefinition erforderlich ist, verwenden Sie sie einfach es direkt.

package com.dao;

import entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Description:
 * date: 2017/3/15 16:28
 */
public interface UserRepository extends JpaRepository<User, Long> {

  User findByName(String name);

}

4. Schreiben Sie den entsprechenden

Einheitentest

, um zu überprüfen, ob der geschriebene Inhalt korrekt ist

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.data.jpa.repository;

import java.io.Serializable;
import java.util.List;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
  List<T> findAll();

  List<T> findAll(Sort var1);

  List<T> findAll(Iterable<ID> var1);

  <S extends T> List<S> save(Iterable<S> var1);

  void flush();

  <S extends T> S saveAndFlush(S var1);

  void deleteInBatch(Iterable<T> var1);

  void deleteAllInBatch();

  T getOne(ID var1);

  <S extends T> List<S> findAll(Example<S> var1);

  <S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

Fügen Sie

zum POM hinzu Erstellen Sie einen Unit-Test-Anwendungsfall

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

srctestjavaUserTest.java

Beispiel für die Ausführung von Ergebnissen

import com.SampleController;
import com.dao.UserRepository;
import com.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * date: 2017/3/15 17:21
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SampleController.class)
public class UserTest {

  @Autowired
  private UserRepository userRepository;

  @Test
  public void saveTest() {
    User user = new User();
    user.setName("王大锤");
    user.setMoblie("13300000000");
    userRepository.save(user);

    Assert.assertEquals("13300000000", userRepository.findByName("王大锤").getMoblie());
  }
}

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Spring Boot JPA-Zugriffs auf MySQL-Beispielcode (Bild und Text). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!