You can fix this Spring Boot database startup failure in about 10 minutes by correcting the JDBC configuration and checking that the MySQL driver is available.
The error usually appears as:
org.springframework.beans.factory.BeanCreationException:
Cannot determine embedded database driver class for database type NONE.
If you want an embedded database please put a supported one on the classpath.
A missing spring.datasource.url is the most common configuration mistake.
A missing MySQL JDBC driver can also prevent Spring Boot from creating a working database connection.
Another frequent cause is placing valid database settings in a configuration file or Spring profile that isn't being loaded.
Quick answer: The error beancreationexception: cannot determine embedded database driver class for database type none means Spring Boot couldn't determine which JDBC driver to use while creating its DataSource. Add the MySQL connection URL, username, password, and Connector/J dependency. Then check that the correct application configuration and Spring profile are active.
Quick fix: BeanCreationException: Cannot determine embedded database driver class for database type NONE
Start with the application's database configuration. This resolves the problem when Spring Boot is missing the JDBC connection details.
Step 1: Configure MySQL in application.properties
Open:
src/main/resources/application.properties
Add these settings:
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/appdb
spring.datasource.username=appuser
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
Replace:
-
127.0.0.1with your MySQL server address. -
3306with the configured MySQL port. -
appdbwith your existing database name. -
appuserandyour_passwordwith valid database credentials.
These are example values, not credentials that will work automatically.
For production, keep passwords outside source control and supply them through your deployment's secret or environment configuration.
Spring Boot can normally determine the MySQL driver from a valid JDBC URL. The explicit driver-class-name setting is useful for troubleshooting, but isn't usually required.
The important property is:
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/appdb
Without that URL, Spring Boot may attempt to find an embedded database instead.
This behavior is documented in the Spring Boot SQL database configuration reference.
Step 2: Add the MySQL JDBC dependency
Open your Maven project's pom.xml.
For a Spring Boot project using its supported dependency management, add:
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
Place it inside the existing <dependencies> section.
Spring Boot's dependency management supplies the compatible version when your project uses its managed dependency definitions.
If your project doesn't use Spring Boot dependency management, you'll need to specify a Connector/J version compatible with your Java and MySQL setup.
For Gradle projects using Groovy DSL, add this to build.gradle:
dependencies {
runtimeOnly 'com.mysql:mysql-connector-j'
}
For Gradle Kotlin DSL (build.gradle.kts):
dependencies {
runtimeOnly("com.mysql:mysql-connector-j")
}
Use the syntax matching your build file. You don't need both.
Step 3: Restart Spring Boot
From the project directory, run:
./mvnw clean spring-boot:run
On Windows PowerShell:
.\mvnw.cmd clean spring-boot:run
These commands assume the project includes the Maven Wrapper and Spring Boot Maven plugin.
For Gradle:
./gradlew bootRun
If the application connects successfully, its startup log should proceed past DataSource initialization.
You may see Hikari connection pool initialization or Hibernate startup messages, depending on the project's dependencies.
If the error changes to Access denied, Unknown database, or Communications link failure, that's useful information. The driver-selection problem may be fixed, and you're now seeing an actual connection problem.
Why Spring Boot cannot determine the embedded database driver
The message sounds like MySQL doesn't support the requested database type. That's not what it means.
NONE is an internal Spring Boot database-type value used in the older error message. It indicates that Spring couldn't identify a supported embedded database during its DataSource configuration.
Spring Boot can automatically configure databases when it has enough information.
For an external MySQL database, it needs a valid JDBC URL and a usable driver.
For an embedded database, it needs an appropriate embedded database dependency, such as H2 or HSQLDB.
When neither path can be configured correctly, DataSource creation fails.
This can happen before the application sends a single SQL query to MySQL.
That's also why changing table definitions, SQL queries, or Hibernate mappings usually won't solve this particular startup error.
Cause 1: Missing spring.datasource.url in application.properties
How to confirm
Inspect:
src/main/resources/application.properties
Look for this exact property:
spring.datasource.url=
If it's missing, empty, or incorrectly named, Spring Boot may not receive the connection URL.
For example, this is not a standard Spring Boot DataSource property:
database.url=jdbc:mysql://127.0.0.1:3306/appdb
Spring Boot won't automatically treat database.url as spring.datasource.url.
How to fix
Use the expected prefix:
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/appdb
spring.datasource.username=appuser
spring.datasource.password=your_password
If you prefer YAML, open:
src/main/resources/application.yml
Then configure:
spring:
datasource:
url: jdbc:mysql://127.0.0.1:3306/appdb
username: appuser
password: your_password
driver-class-name: com.mysql.cj.jdbc.Driver
Don't put these settings under spring.jpa or spring.hibernate.
Those sections handle different database-related configuration.
Also check the file location. A file accidentally placed under src/main/resources/static isn't treated as the normal application configuration file.
Cause 2: MySQL JDBC driver not found in the classpath
A correct database URL doesn't help if the MySQL connector isn't available at runtime.
Depending on your Spring Boot version and configuration, the application might report:
Failed to determine a suitable driver class
Or:
Cannot load driver class: com.mysql.cj.jdbc.Driver
These errors are related, but not identical to the original database type NONE message.
How to confirm
For a Maven project using the current Connector/J artifact, run:
./mvnw dependency:tree -Dincludes=com.mysql:mysql-connector-j
You should find a dependency similar to:
com.mysql:mysql-connector-j:jar:...:runtime
The actual version depends on your project.
For Gradle:
./gradlew dependencies --configuration runtimeClasspath
Search the output for mysql-connector-j.
If the driver isn't listed, check the dependency declaration, dependency exclusions, and build configuration.
How to fix
Add the dependency shown in the quick fix, reload the project, and rebuild.
Older Spring Boot applications may use:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
That's the older Maven artifact name. Don't replace it blindly without checking the project's Spring Boot version and dependency management.
For current MySQL Connector/J releases, the driver class is:
com.mysql.cj.jdbc.Driver
The older class name:
com.mysql.jdbc.Driver
is deprecated in newer Connector/J versions.
MySQL confirms the current driver name in its Connector/J documentation.
My preference is to let Spring Boot manage the connector version whenever possible rather than manually mixing unrelated library versions.
Cause 3: Spring Boot isn't loading your database profile
This one is easy to miss because the configuration can look perfectly correct.
Imagine your database settings live here:
src/main/resources/application-dev.properties
With:
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/appdb
spring.datasource.username=appuser
spring.datasource.password=your_password
But you launch the application without activating dev.
Spring Boot might never apply those properties.
How to confirm
Check the startup log for a message about active profiles.
You might see:
No active profile set, falling back to default profiles
The exact wording varies across Spring Boot versions.
How to fix
Activate your development profile.
With Maven:
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev
Or set the environment variable on Linux or macOS:
SPRING_PROFILES_ACTIVE=dev ./mvnw spring-boot:run
On Windows PowerShell:
$env:SPRING_PROFILES_ACTIVE = "dev"
.\mvnw.cmd spring-boot:run
You can also set the active profile in the base application.properties:
spring.profiles.active=dev
Use that only when selecting the profile in application configuration makes sense for your deployment.
Don't put spring.profiles.active inside application-dev.properties on modern Spring Boot versions. Profile activation belongs in a non-profile-specific configuration source.
One more gotcha: environment variables, command-line arguments, and external configuration files can override packaged configuration.
A correct setting in your source repository doesn't guarantee that's the value the running application receives.
Cause 4: The JDBC URL or MySQL server address is wrong
Once Spring identifies the JDBC driver, the next step is establishing a network connection.
A typical MySQL JDBC URL looks like:
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/appdb
The jdbc:mysql:// prefix matters.
This is not a valid MySQL JDBC URL:
spring.datasource.url=mysql://127.0.0.1:3306/appdb
The second format is missing jdbc:.
Check that MySQL is reachable
Try connecting directly with the MySQL command-line client:
mysql -h 127.0.0.1 -P 3306 -u appuser -p appdb
Enter your password when prompted.
If it works, run:
SELECT 1;
You should get a result containing 1.
If you receive Access denied, investigate credentials and MySQL account permissions.
If you receive Unknown database, confirm that the named database exists.
If you receive a connection error, check that MySQL is running and listening on the expected interface and port.
For another explanation of MySQL host values, see our guide to the host parameter in mysqli_connect(). That's the PHP interface, not JDBC, but the server address and connection troubleshooting concepts overlap.
Important: A MySQL connection failure normally produces a different underlying exception from database type NONE. Don't spend time resetting passwords until Spring Boot can actually select its JDBC driver.
Cause 5: Spring Boot tries to configure a database your application doesn't use
Sometimes the application isn't supposed to connect to MySQL at all.
For example, you create a Spring Boot web service that only handles HTTP requests, but the project includes:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
Spring Boot sees database-related dependencies and attempts to configure a DataSource.
With no JDBC URL or embedded database available, initialization can fail.
How to confirm
Check pom.xml or build.gradle for dependencies such as:
spring-boot-starter-data-jpa
spring-boot-starter-jdbc
Then check whether your application actually uses JDBC, repositories, JPA entities, or database-backed services.
How to fix
If the dependency was added accidentally, remove it.
If the application genuinely doesn't need a database, you can exclude DataSource auto-configuration:
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
@SpringBootApplication(
exclude = {DataSourceAutoConfiguration.class}
)
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
Adjust the package and application class to match your project.
This prevents Spring Boot from automatically creating a DataSource.
Don't use this as a shortcut in a real MySQL/JPA application. Excluding auto-configuration doesn't repair the connection. It may simply replace the original error with missing DataSource, repository, or entity manager errors.
If you actually want an in-memory database for development or tests, add an appropriate embedded database dependency instead, such as H2:
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
Only do that when an embedded database is intentional. It isn't a substitute for MySQL.
Cause 6: The app works locally but fails after packaging or deployment
A working IDE launch doesn't prove the deployed application has the same configuration.
The deployed process may use another active profile, missing environment variables, or a package without the expected JDBC dependency.
Check the packaged application
First build the application:
./mvnw clean package
For an executable Spring Boot JAR, inspect its contents:
jar tf target/your-app.jar
Replace your-app.jar with the actual output filename.
Search the listing for the MySQL connector under the packaged libraries, typically within BOOT-INF/lib for an executable Spring Boot JAR using that layout.
Also inspect the packaged configuration under BOOT-INF/classes.
If your project builds a different deployment format, inspect that format instead.
A clean package can also reveal resource-copying mistakes.
For example, the source application.properties might contain a database URL while the copied configuration in target/classes is empty or outdated.
A clean rebuild removes stale build output before packaging.
If MySQL is hosted separately from the application, make sure the JDBC URL uses the hostname reachable from the application's runtime environment. Inside Docker, 127.0.0.1 refers to the container itself, not automatically to the host machine.
If nothing worked: capture the real Spring Boot failure
At this point, stop changing random properties and collect the first meaningful exception.
Spring's top-level BeanCreationException often wraps a more specific failure.
The useful message is frequently near the bottom of the stack trace, following Caused by:.
Enable Spring Boot debug output
For Maven:
./mvnw spring-boot:run -Dspring-boot.run.arguments=--debug
For Gradle:
./gradlew bootRun --args='--debug'
Debug mode shows more information about Spring Boot's auto-configuration decisions.
It can help establish why DataSource auto-configuration was selected and which configuration conditions matched.
Debug output doesn't automatically print every effective database property.
Save the startup log
On Linux or macOS:
./mvnw spring-boot:run > startup.log 2>&1
On Windows PowerShell:
.\mvnw.cmd spring-boot:run *> startup.log
Open startup.log and search for:
Caused by:
DataSourceAutoConfiguration
DataSourceProperties
Failed to determine a suitable driver class
Cannot load driver class
Access denied
Communications link failure
Interpret the first relevant root cause rather than treating every nested exception as a separate failure.
A useful troubleshooting report includes the Spring Boot version, active profile, sanitized JDBC URL, relevant dependency tree, and the first underlying exception.
Remove passwords, tokens, and other secrets before sharing logs or configuration.
For comparison, problems such as Laravel migrations and MySQL seeding failures happen at a different stage. If your Spring application never created its DataSource, investigating SQL inserts or table relationships is premature.
FAQ
Why does Spring Boot say database type NONE when I'm using MySQL?
NONE doesn't refer to a MySQL storage engine or database type. It's part of the older Spring Boot error wording used when an embedded database can't be identified during DataSource initialization.
Check that Spring receives a valid spring.datasource.url and that the required MySQL driver is available.
Is spring.datasource.driver-class-name required for MySQL?
Usually not. Spring Boot can identify the driver from a correctly configured jdbc:mysql:// URL when Connector/J is on the runtime classpath.
You can explicitly set spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver while troubleshooting. The setting won't help if the driver library itself is missing.
Can I fix this by adding H2 instead of MySQL Connector/J?
Only if you intend to use H2 as an embedded database. Adding H2 may allow a separate development or test application to start, but it doesn't configure a connection to your MySQL server.
For a MySQL-backed application, use the MySQL JDBC driver and the correct connection properties.
Why does the application work in the IDE but fail with java -jar?
The IDE and packaged application might not load the same profiles, environment variables, dependencies, or configuration files.
Compare the effective startup settings and inspect the packaged JAR. Don't assume the database driver is included simply because the project compiles successfully.
What's the difference between "Cannot determine embedded database driver class" and "Failed to determine a suitable driver class"?
Both errors concern Spring Boot's ability to configure a JDBC DataSource. The first is associated with older Spring Boot error messages, while newer versions commonly report the second.
The same diagnostic approach applies: check the JDBC URL, available driver, loaded configuration, and active profile before investigating the MySQL server.
If you're still getting beancreationexception: cannot determine embedded database driver class for database type none, gather the sanitized startup log and dependency tree, then use HeadsNTail services if you need hands-on help identifying the remaining configuration issue.
Originally published at headsntail.com. Free tools for PHP, Laravel and cPanel work: headsntail.com/tools.
