Getting started with Spring Boot microservices

What you need to start

A typical service imports the platform modules it needs, keeps business logic in its own modules, and enables platform capabilities through regular Spring Boot configuration.

• Import dependency management or the required module versions
• Add only the runtime modules the service actually needs
• Keep a normal Spring Boot entry point
• Register resources and configure the Registry endpoint

Adoption model

Spring Middleware is modular. You do not need to adopt everything on day one. Start with the smallest useful set of modules and keep the service architecture explicit.

• Recommended approach: import the BOM and add only the runtime modules you need.
• Lightweight approach: add individual modules with explicit versions for smaller integrations.
• Main goal: keep versions aligned and avoid per-service dependency drift.

Typical module layout

Runtime integration

The *-boot module usually depends on Spring Middleware platform modules such as app, messaging modules, GraphQL support, or data integrations depending on the service role.

• Keep shared DTOs and interfaces separate from runtime wiring
• Keep business logic in your own core module
• Use the Boot module as the integration point for platform capabilities

Managed versions

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring.boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>

    <dependency>
      <groupId>io.github.spring-middleware</groupId>
      <artifactId>app</artifactId>
      <version>${spring-middleware.app.version}</version>
    </dependency>

    <dependency>
      <groupId>io.github.spring-middleware</groupId>
      <artifactId>api</artifactId>
      <version>${spring-middleware.api.version}</version>
    </dependency>
  </dependencies>
</dependencyManagement>

Runtime modules

<dependencies>
  <dependency>
    <groupId>io.github.spring-middleware</groupId>
    <artifactId>app</artifactId>
  </dependency>

  <dependency>
    <groupId>io.github.spring-middleware</groupId>
    <artifactId>kafka-core</artifactId>
  </dependency>
</dependencies>

Declarative client

@MiddlewareClient(service = "product")
public interface ProductClient {

    @GetMapping("/products/{id}")
    ProductDto getProduct(@PathVariable("id") UUID id);
}

Registered controller

@RestController
@Register
@RequestMapping("/catalogs")
public class CatalogController {
    // endpoints
}

What the example includes

• Root aggregator pom.xml
• Minimal catalog-service module
• Spring Boot main class
• Realistic application.yml
• Declarative client usage with ProductApi

Build

mvn -T 1C -DskipTests clean package

Run

java -jar target/your-service-boot-<version>.jar

Common early checks

• Use the BOM to keep module versions aligned across services
• Enable topic auto-creation locally, but manage topics explicitly in production
• Check .dockerignore if Docker builds cannot see the generated jar
• Make sure required configuration properties can bind in tests

What this page is for

This page is intentionally narrow. It helps a service cross the initial integration line. Deeper runtime behavior belongs in the architecture, registry, communication, messaging, GraphQL, security, and error model pages.