Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

Spring Boot Quickstart (#48396)

Illia Basalaiev27f18f03595b
diff --git a/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts b/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
index 196a9cb40e8..b3a88a149ea 100644
--- a/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
+++ b/apps/docs/components/Navigation/NavigationMenu/NavigationMenu.constants.ts
@@ -422,6 +422,11 @@ export const gettingstarted: NavMenuConstant = {
url: '/guides/getting-started/quickstarts/ruby-on-rails' as `/${string}`,
enabled: !jsOnly,
},
+ {
+ name: 'Spring Boot',
+ url: '/guides/getting-started/quickstarts/spring-boot' as `/${string}`,
+ enabled: !jsOnly,
+ },
{
name: 'SolidJS',
url: '/guides/getting-started/quickstarts/solidjs',
diff --git a/apps/docs/content/guides/getting-started/quickstarts/spring-boot.mdx b/apps/docs/content/guides/getting-started/quickstarts/spring-boot.mdx
new file mode 100644
index 00000000000..cc0015e5fcf
--- /dev/null
+++ b/apps/docs/content/guides/getting-started/quickstarts/spring-boot.mdx
@@ -0,0 +1,218 @@
+---
+title: 'Use Supabase with Spring Boot'
+subtitle: 'Learn how to create a Spring Boot project and connect it to your Supabase project.'
+breadcrumb: 'Framework Quickstarts'
+---
+
+<AiPrompt id="spring-boot" />
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+- Java 17 or later, which you can check with `java -version`
+- `curl` and `unzip`, to download and extract the generated project
+
+## 1. Create a Spring Boot project
+
+Use [Spring Initializr](https://start.spring.io) to scaffold a new project with the Web, Spring Data JPA, and Postgres Driver dependencies. Run the following from the directory where you keep your projects.
+
+```bash
+curl https://start.spring.io/starter.zip \
+ -d dependencies=web,data-jpa,postgresql \
+ -d type=maven-project \
+ -d language=java \
+ -d groupId=com.example \
+ -d artifactId=instruments \
+ -d name=instruments \
+ -o instruments.zip
+unzip instruments.zip -d instruments && cd instruments
+```
+
+## 2. Install Supabase's Agent Skills (optional)
+
+Supabase's [Agent Skills](/docs/guides/ai-tools/ai-skills) is a curated set of instructions that give your AI agent procedural knowledge about working with Supabase.
+
+Install them so your AI coding agent can produce more accurate, reliable code using current Supabase patterns, such as authentication, server-side rendering, and database migrations, rather than relying solely on training data.
+
+To install, run the following command in the root of your project:
+
+```bash
+npx skills add supabase/agent-skills
+```
+
+## 3. Set up the Postgres connection details
+
+Go to [database.new](https://database.new) and create a new Supabase project. Save your database password securely.
+
+When your project is up and running, navigate to its dashboard and click on [Connect](/dashboard/project/_?showConnect=true&method=session).
+
+<Admonition type="caution">
+
+The Transaction pooler (port `6543`) doesn't work as your app's main data source, because Spring Data JPA uses Hibernate, which relies on server-side prepared statements. Use the Session pooler, or the direct connection string if you're in an [IPv6 environment](/docs/guides/troubleshooting/supabase--your-network-ipv4-and-ipv6-compatibility-cHe3BP) or have the [IPv4 Add-On](/docs/guides/platform/ipv4-address).
+
+</Admonition>
+
+Under the **Session pooler** (port `5432`), select the **JDBC** tab and copy the connection string. Replace the password placeholder with your saved database password, and [percent-encode](https://en.wikipedia.org/wiki/Percent-encoding) any reserved characters it contains, such as `&`, `#`, `?`, or a space.
+
+<Admonition type="note">
+
+You can reset your database password in your [Database Settings](/dashboard/project/_/database/settings) if you do not have it.
+
+</Admonition>
+
+The connection string contains your database password, and `application.properties` is committed with your project. Set the string as an environment variable instead, and set it the same way on whatever platform you deploy to.
+
+```bash
+export SUPABASE_DB_URL='jdbc:postgresql://xxxx.pooler.supabase.com:5432/postgres?user=postgres.xxxx&password=[YOUR-PASSWORD]&sslmode=require'
+```
+
+The string you copied doesn't set `sslmode`, so add it. The driver defaults to `prefer`, which falls back to sending your data in plaintext if the encrypted attempt fails. You can also [enforce SSL](/docs/guides/platform/ssl-enforcement) on the database side.
+
+Then reference the variable, along with the driver, in `src/main/resources/application.properties`.
+
+```text name=src/main/resources/application.properties
+spring.datasource.url=${SUPABASE_DB_URL}
+spring.datasource.driver-class-name=org.postgresql.Driver
+spring.jpa.hibernate.ddl-auto=update
+```
+
+If the app fails to start with `Unable to determine Dialect without JDBC metadata`, Hibernate couldn't open a connection at all. Look above that line in the logs for the real cause, most commonly `password authentication failed`.
+
+## 4. Change the default schema
+
+By default Hibernate creates tables in the `public` schema. We recommend changing this as Supabase exposes the `public` schema as a [data API](/docs/guides/api).
+
+Create the schema from the [Table Editor](/dashboard/project/_/editor) as your app will need it before start. Then point **Hibernate** at it in `application.properties`.
+
+```text name=src/main/resources/application.properties
+spring.jpa.properties.hibernate.default_schema=app
+```
+
+## 5. Create an entity and repository
+
+Spring Data JPA maps Java classes to database tables. Create an `Instrument` entity in `src/main/java/com/example/instruments/Instrument.java`. With `spring.jpa.hibernate.ddl-auto=update` set, Hibernate creates the `instruments` table for you when the app starts.
+
+```java name=src/main/java/com/example/instruments/Instrument.java
+package com.example.instruments;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "instruments")
+public class Instrument {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ private String name;
+
+ public Instrument() {}
+
+ public Instrument(String name) {
+ this.name = name;
+ }
+
+ public Long getId() {
+ return id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+}
+```
+
+Create an `InstrumentRepository` interface in the same package. Extending `JpaRepository` gives you `findAll`, `save`, and other query methods without writing any implementation.
+
+```java name=src/main/java/com/example/instruments/InstrumentRepository.java
+package com.example.instruments;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface InstrumentRepository extends JpaRepository<Instrument, Long> {}
+```
+
+## 6. Seed sample data
+
+Add a `CommandLineRunner` bean to `InstrumentsApplication.java` that saves some sample instruments the first time the app starts.
+
+```java name=src/main/java/com/example/instruments/InstrumentsApplication.java
+package com.example.instruments;
+
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+@SpringBootApplication
+public class InstrumentsApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(InstrumentsApplication.class, args);
+ }
+
+ @Bean
+ CommandLineRunner seedInstruments(InstrumentRepository instrumentRepository) {
+ return args -> {
+ if (instrumentRepository.count() == 0) {
+ instrumentRepository.save(new Instrument("violin"));
+ instrumentRepository.save(new Instrument("viola"));
+ instrumentRepository.save(new Instrument("cello"));
+ }
+ };
+ }
+}
+```
+
+## 7. Query data from the app
+
+Create an `InstrumentController` that fetches every row from the `instruments` table through the repository and returns it as JSON.
+
+```java name=src/main/java/com/example/instruments/InstrumentController.java
+package com.example.instruments;
+
+import java.util.List;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class InstrumentController {
+
+ private final InstrumentRepository instrumentRepository;
+
+ public InstrumentController(InstrumentRepository instrumentRepository) {
+ this.instrumentRepository = instrumentRepository;
+ }
+
+ @GetMapping("/instruments")
+ public List<Instrument> getInstruments() {
+ return instrumentRepository.findAll();
+ }
+}
+```
+
+## 8. Start the app
+
+Run the Spring Boot app, and go to http://localhost:8080/instruments in your browser. You should see the list of instruments.
+
+```bash
+./mvnw spring-boot:run
+```
+
+## Next steps
+
+- Set up [Auth](/docs/guides/auth) for your app
+- Replace `ddl-auto` with [database migrations](/docs/guides/deployment/database-migrations) before going to production
+- [Insert more data](/docs/guides/database/import-data) into your database
+- Upload and serve static files using [Storage](/docs/guides/storage)
diff --git a/apps/docs/data/ai-prompts.data.ts b/apps/docs/data/ai-prompts.data.ts
index 74cf6930033..788b3acf364 100644
--- a/apps/docs/data/ai-prompts.data.ts
+++ b/apps/docs/data/ai-prompts.data.ts
@@ -201,6 +201,30 @@ database.new and run the instruments table SQL. Then:
REFERENCE
https://supabase.com/docs/guides/getting-started/quickstarts/solidjs.md`,
+ 'spring-boot': `Help me add Supabase to my Spring Boot project. Create a Supabase project at
+database.new. Then:
+1. Run \`curl https://start.spring.io/starter.zip -d dependencies=web,data-jpa,postgresql
+ -d type=maven-project -d language=java -d groupId=com.example -d artifactId=instruments
+ -d name=instruments -o instruments.zip\` and unzip it to scaffold the project.
+2. Copy the JDBC connection string for the Session pooler (port 5432) from the Supabase
+ Connect panel and export it as a \`SUPABASE_DB_URL\` environment variable, so the
+ password stays out of source control. Set \`spring.datasource.url=\${SUPABASE_DB_URL}\`
+ and \`spring.datasource.driver-class-name\` in \`application.properties\`. Avoid the
+ Transaction pooler (port 6543) since Hibernate relies on prepared statements.
+3. Set \`spring.jpa.hibernate.ddl-auto=update\` and
+ \`spring.jpa.properties.hibernate.default_schema\` in \`application.properties\`, so
+ Hibernate creates tables outside the \`public\` schema that Supabase exposes as a data API.
+4. Create an \`Instrument\` JPA entity mapped to the \`instruments\` table with
+ \`@Table(name = "instruments")\`, and an \`InstrumentRepository\` extending
+ \`JpaRepository\`.
+5. Add a \`CommandLineRunner\` bean to \`InstrumentsApplication\` that seeds the table
+ with a few instruments the first time the app starts.
+6. Create an \`InstrumentController\` with a \`GET /instruments\` endpoint that returns
+ \`instrumentRepository.findAll()\`.
+7. Run \`./mvnw spring-boot:run\` and open http://localhost:8080/instruments.
+
+REFERENCE
+https://supabase.com/docs/guides/getting-started/quickstarts/spring-boot.md`,
sveltekit: `Help me add Supabase to my SvelteKit project. Create a Supabase project at
database.new and run the instruments table SQL. Then:
1. Run \`npx sv create my-app\` to scaffold the app.
diff --git a/supa-mdx-lint/Rule001HeadingCase.toml b/supa-mdx-lint/Rule001HeadingCase.toml
index 5eefe357017..6a497f7929a 100644
--- a/supa-mdx-lint/Rule001HeadingCase.toml
+++ b/supa-mdx-lint/Rule001HeadingCase.toml
@@ -228,6 +228,9 @@ may_uppercase = [
"Spend Cap",
"Spotify",
"Spotify Developers?",
+ "Spring Boot",
+ "Spring Data JPA",
+ "Spring Initializr",
"Sqitch",
"Storage",
"Studio",
diff --git a/supa-mdx-lint/Rule003Spelling.toml b/supa-mdx-lint/Rule003Spelling.toml
index 6c67ee97771..2d9bd6b8d3f 100644
--- a/supa-mdx-lint/Rule003Spelling.toml
+++ b/supa-mdx-lint/Rule003Spelling.toml
@@ -270,6 +270,7 @@ allow_list = [
"Inbucket",
"Inferencer",
"Infisical",
+ "Initializr",
"IntelliJ",
"IntelliSense",
"[Ii]nviter's",