Spring Boot kann nicht automatisch das Datenbankschema erstellen

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

@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

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.

Die folgenden beiden Einstellungen funktionieren jedoch.

spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=create

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

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. 

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.

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

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.

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);


    }
}

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.

Sie fügen einfach createDatabaseIfNotExist=true so hinzu

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

in Ihre Datei application.properties

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

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

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

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