wake-up-neo.com

Spring Boot kann nicht automatisch das Datenbankschema erstellen

Ich kann den Spring Boot beim Starten nicht automatisch zum Laden des Datenbankschemas veranlassen.

Hier sind meine application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=test
spring.datasource.password=
spring.datasource.driverClassName = com.mysql.jdbc.Driver

spring.jpa.database = MYSQL

spring.jpa.show-sql = true

spring.jpa.hibernate.ddl-auto = create
spring.jpa.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.naming_strategy = org.hibernate.cfg.ImprovedNamingStrategy

Hier ist meine Application.Java:

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

Hier ist eine Beispielentität:

@Entity
@Table(name = "survey")
public class Survey implements Serializable {

    private Long _id;

    private String _name;

    private List<Question> _questions;

    /**
     * @return survey's id.
     */
    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "survey_id", unique = true, nullable = false)
    public Long getId() {
        return _id;
    }

    /**
     * @return the survey name.
     */
    @Column(name = "name")
    public String getName() {
        return _name;
    }


    /**
     * @return a list of survey questions.
     */
    @OneToMany(mappedBy = "survey")
    @OrderBy("id")
    public List<Question> getQuestions() {
        return _questions;
    }

    /**
     * @param id the id to set to.
     */
    public void setId(Long id) {
        _id = id;
    }

    /**
     * @param name the name for the question.
     */
    public void setName(final String name) {
        _name = name;
    }

    /**
     * @param questions list of questions to set.
     */
    public void setQuestions(List<Question> questions) {
        _questions = questions;
    }
}

Irgendwelche Ideen, was ich falsch mache?

34
napentathol

Es gibt mehrere mögliche Ursachen:

  1. Ihre Entitätsklassen befinden sich im selben oder in einem relativen Unterpaket, in dem Sie Ihre Klasse mit @EnableAutoConfiguration. haben. Wenn dies nicht der Fall ist, werden sie von Ihrer Spring-App nicht angezeigt und daher in db nichts erstellt
  2. Überprüfen Sie Ihre Konfiguration. Es scheint, dass Sie bestimmte Optionen für den Ruhezustand verwenden. Versuchen Sie, diese durch Folgendes zu ersetzen:

    spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
    spring.jpa.hibernate.ddl-auto=update
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/test
    spring.datasource.username=test
    spring.datasource.password=
    
  3. Ihr application.properties muss sich im src/main/resources-Ordner befinden.

Wenn Sie den Dialekt nicht richtig angegeben haben, wird möglicherweise versucht, standardmäßig zusammen mit der Boot-In-Memory-Datenbank gebündelt zu werden, und (wie bei mir) konnte ich feststellen, dass er versucht, sich mit der lokalen HSQL-Instanz (siehe Konsolenausgabe) zu verbinden, und die Aktualisierung schlägt fehl das Schema.

43
borys86

Haben Sie versucht, es auszuführen mit:

spring.jpa.generate-ddl=true

und dann 

spring.jpa.hibernate.ddl-auto = create

Standardmäßig wird die DDL-Ausführung (oder -Validierung) verschoben, bis der ApplicationContext gestartet wurde. Es gibt auch ein spring.jpa.generate-ddl-Flag, das jedoch nicht verwendet wird, wenn Hibernate autoconfig aktiv ist, da die ddl-auto-Einstellungen feiner sind.

siehe spring-boot-features

38
liorsolomon
@SpringBootApplication
@EnableConfigurationProperties
@EntityScan(basePackages = {"com.project.ppaa.model"})  // scan JPA entities
public class Application {

  private static ConfigurableApplicationContext applicationContext;

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

es sollte automatisch funktionieren, aber wenn nicht, können Sie das Basispaket eingeben

@EntityScan(basePackages = {"com.project.ppaa.model"})  // scan JPA entities manually
12
Ar maj

Wenn Ihre Entitätsklasse nicht in demselben Paket wie Ihre Hauptklasse ist, können Sie in der Hauptklasse @EntityScan annotation verwenden, wobei Sie auch die Entität angeben, die Sie speichern oder packen möchten. Wie dein Modellpaket.

Über:

spring.jpa.hibernate.ddl-auto = create

Sie können die Option update verwenden. Es werden keine Daten gelöscht und Tabellen werden auf dieselbe Weise erstellt.

6
erickbhrener

Die folgenden beiden Einstellungen funktionieren jedoch.

spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=create
5
Taf
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update

MySQL5Dialect ist ein Trick, zuvor habe ich 'MySQLDialect' benutzt

2
asifaftab87

Ich habe auch das gleiche Problem. Es stellte sich heraus, dass ich die Annotation @PropertySource für die Hauptanwendungsklasse gesetzt habe, um eine andere Basis-Eigenschaftendatei zu lesen, so dass die normale "application.properties" nicht mehr verwendet wird. 

2
user3206144

Das habe ich getan, nachdem ich alle Antworten oben gelesen hatte.

  1. Hinzufügen spring.jpa.hibernate.ddl-auto=update mit anderen einfachen Eigenschaften zu application.properties
  2. lauf
  3. In der Konsole können Sie den Fehler sehen. An einer Stelle im Fehler finden Sie den von dieser Software generierten SQL-Code zum Erstellen Ihrer Entitätstabelle.
  4. Kopieren Sie diesen SQL-Code und fügen Sie ihn separat in Ihr DBMS ein, um die Tabelle zu erstellen.
  5. Danach starte die App erneut.
1

In meinem Fall wurden die Tabellen nicht automatisch erstellt, obwohl ich JPArepository ..__ verwendet habe. Nachdem Sie die untenstehende Eigenschaft in meiner Datei "springboot app application.properties" hinzugefügt haben, werden die Tabellen jetzt automatisch erstellt .spring.jpa .hibernate.ddl-auto = update

1
Jayant Nayak

Sie müssen Konfigurationen bereitstellen, die Ihre Spring Boot-Version und die Version der von ihr heruntergeladenen Bibliotheken berücksichtigen.

Mein Setup: Spring Boot 1.5.x (in meinem Fall 1.5.10) lädt Hibernate v5.x herunter

Verwenden Sie unten nur, wenn Ihr Spring Boot-Setup Hibernate v4 heruntergeladen hat.

spring.jpa.hibernate.naming_strategy = org.hibernate.cfg.ImprovedNamingStrategy

Hibernate 5 unterstützt oben nicht.

Wenn Ihr Spring-Boot-Setup Hibernate v5.x heruntergeladen hat, ziehen Sie die folgende Definition vor:

spring.jpa.hibernate.naming.physical-strategy = org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

WICHTIG: In Ihrer Spring Boot-Anwendungsentwicklung sollten Sie die Annotation bevorzugen: @SpringBootApplication, die mit: @SpringBootConfiguration and @EnableAutoConfiguration überkommentiert wurde.

NOW Wenn sich die Entitätsklassen in einem anderen Paket befinden als das Paket, in dem sich Ihre Hauptklasse befindet, werden diese Pakete nicht von Spring Boot geprüft.

Deshalb müssen Sie Annotation explizit definieren: @EntityScan(basePackages = { "com.springboot.entities" })
Diese Anmerkung durchsucht JPA-basierte annotierte Entitätsklassen (und andere wie MongoDB, Cassandra usw.)

HINWEIS: "Com.springboot.entities" ist der Name des benutzerdefinierten Pakets.

Im Folgenden habe ich die Eigenschaften von Hibernate und JPA in application.properties zum Erstellen von Tabellen definiert: -

spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.url = jdbc: mysql: // localhost: 3333/development? useSSL = true spring.datasource.username = admin
spring.datasource.password =

spring.jpa.open-in-view = false
spring.jpa.hibernate.ddl-auto = create
spring.jpa.generate-ddl = true 
spring.jpa.hibernate.use-new-id-generator-mappings = true
spring.jpa.hibernate.naming.physical-strategy = org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
spring.jpa.hibernate.naming.strategy = org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.show-sql = wahr
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.format_sql = true

Ich kann mit meiner oben genannten Konfiguration Tabellen erstellen.

Verweisen Sie es und ändern Sie gegebenenfalls Ihren Code.

1
Philip Dilip
Use this Sample code

application.properties
# DataSource settings: set here your own configurations for the database 
# connection. In this example we have "dojsb" as database name and 
# "root" as username and password.
spring.datasource.url =jdbc:postgresql://localhost:5432/usman
spring.datasource.username = postgres
spring.datasource.password = 12345

# Keep the connection alive if idle for a long time (needed in production)
spring.datasource.testWhileIdle = true
spring.datasource.validationQuery = SELECT 1

# Show or not log for each sql query
spring.jpa.show-sql = true

# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = create

# Naming strategy
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy

# Use spring.jpa.properties.* for Hibernate native properties (the prefix is
# stripped before adding them to the entity manager)

# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

server.port = 8963



Entity Class:



import Java.sql.Timestamp;
import Java.util.UUID;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.Type;


@Entity
@Table(name = "QUEUERECORDS")
public class QueuesRecords {
    @Id
    private UUID id;

    @Column(name="payload", nullable = true)
    @Type(type="text")
    private String payload;


    @Column(name="status", nullable = true)
    @Type(type="text")
    private String status;

    private Timestamp starttime;

    private Timestamp endtime;

    @Column(name="queueid",nullable= true)
    @Type(type="text")
    private String queueid;

    public UUID getId() {
        return id;
    }

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

    public String getPayload() {
        return payload;
    }

    public void setPayload(String payload) {
        this.payload = payload;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Timestamp getStarttime() {
        return starttime;
    }

    public void setStarttime(Timestamp starttime) {
        this.starttime = starttime;
    }

    public Timestamp getEndtime() {
        return endtime;
    }

    public void setEndtime(Timestamp endtime) {
        this.endtime = endtime;
    }

    public String getQueueid() {
        return queueid;
    }

    public void setQueueid(String queueid) {
        this.queueid = queueid;
    }



}



Main class



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class Test{

    public static void main(String[] args) {

        SpringApplication.run(Test.class, args);


    }
}
0
Usman Yaqoob

Ich hatte vorher das gleiche Problem. Mein Problem war die Entity-Beziehung, die ich mithilfe einer "Liste" aufzubauen versuchte. Ich wusste, dass es die Ursache war, weil das Programm ohne die Listenvariable gut lief. In Ihrem Fall denke ich, das Problem ist:

private List<Question> _questions;

Ich gehe davon aus, dass Sie bereits eine Klasse namens Question haben. Also versuchen Sie es mit:

@OneToMany
private Question _questions;

Aber die Sache ist, dass Sie in Ihrer Methode damit umgehen, so dass eine Liste zurückgegeben wird. Ich habe Spring Data JPA mit CrudRepository verwendet. Wenn Sie sich also entscheiden, es zu benutzen, sieht Ihr so ​​aus:

public List<Question> findById( Long _id );

Es gibt weitere Änderungen, die Sie vornehmen müssen, aber diese sind ziemlich einfach und unkompliziert. In diesem Java-Brains-Video können Sie besser nachvollziehen, was noch zu ändern ist.

0
lamarre

Sie fügen einfach createDatabaseIfNotExist=true so hinzu

spring.datasource.url=jdbc:mysql://localhost:3306/test?createDatabaseIfNotExist=true&amp;amp;useUnicode=true&amp;amp;characterEncoding=utf-8&amp;amp;autoReconnect=true

in Ihre Datei application.properties

0
Abderrahmane

Einfach fügen wir nach dem Semikolon hinzu 
spring.jpa.hibernate.ddl-auto = create;
was falsch ist 
spring.jpa.hibernate.ddl-auto = create 
genug

0
Ansar Mohamed

wenn Ihre Datenbank MySQL ist:

spring.jpa.hibernate.ddl-auto=update
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/your_database
spring.datasource.username=root
spring.datasource.password=root

wenn Ihre Datenbank PostgreSQL ist:

spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:postgresql://localhost:3306/your_database
spring.datasource.username=root
spring.datasource.password=root
0
Wendell Tufano

Die Antwort von Abderrahmane ist korrekt: Fügen Sie ?createDatabaseIfNotExist=true In die Eigenschaft url ein. Es scheint, dass ddl-auto Nichts tut.

0
Camilo

Fügen Sie einfach den Parameter createDatabaseIfNotExist = true in die Frühjahrs-Datenquellen-URL ein

Beispiel: spring.datasource.url = jdbc: mysql: // localhost: 3306/test? CreateDatabaseIfNotExist = true

0
Nitin Pawar