How would I integrate Wire with Spring Boot?

[ursusursus]

Spring boot has this gRPC integration but it's based on the stock google impl https://docs.spring.io/spring-boot/reference/io/grpc.html which gives the bad kotlin ergonomics. I'd therefore like to use Wire.

Is that possible?

[false200]

@ursusursus

Yes, it’s possible, but not as a drop-in replacement for Spring Boot’s default gRPC setup. Spring Boot gRPC is fundamentally built around grpc-java and protobuf-java, while Wire uses its own Kotlin-first codegen. That means you’re not just swapping a library, you’re swapping the entire generated API layer.

What Spring Boot expects

Spring gRPC is designed around:

• Protobuf-generated messages (com.google.protobuf.*)
• Generated stubs like *Grpc
• Server implementations extending BindableService

This is what Spring auto-detects and registers into its Netty gRPC server.

Wire does not generate any of these. Instead, it generates Kotlin data classes and service interfaces, so Spring cannot consume them directly.

What Wire changes

With Wire, your .proto generates:

• Kotlin message types instead of protobuf builders
• FooServer / FooClient interfaces instead of *Grpc stubs
• Coroutine-based or suspending APIs instead of blocking stubs

So the compatibility gap is at the codegen boundary, not at the transport level.

How to integrate Wire with Spring Boot

You keep Spring Boot for lifecycle and DI, and replace only the gRPC codegen layer.

1. Replace protobuf codegen with Wire

Configure Wire in Gradle:

plugins {
  id("com.squareup.wire")
}

wire {
  kotlin {
    rpcRole = "server"
    rpcCallStyle = "suspending"
  }
}

At this point, you are no longer using Spring’s protobuf-based generation for those modules.

2. Bridge Wire services into Spring

Spring still requires BindableService beans.

Wire does not natively produce BindableService, so you must bridge it using either:

• wire-grpc-server (experimental)
• or a manual adapter layer

Example pattern:

@Service
class RouteGuideService : RouteGuideServer {
  override suspend fun GetFeature(request: Point): Feature {
    // implementation
  }
}

Then expose it to Spring:

@Configuration
class GrpcConfig {
  @Bean
  fun routeGuideBindable(service: RouteGuideService): BindableService {
    return GeneratedRouteGuideGrpcService(service)
  }
}

This GeneratedRouteGuideGrpcService comes from Wire’s gRPC server schema handler or helper library, depending on your setup.

3. Client-side integration

You do not use @ImportGrpcClients with Wire.

Instead, you build clients directly:

val client = GrpcClient.Builder()
  .baseUrl("https://localhost:9090")
  .build()

val routeGuide = client.create(RouteGuideClient::class)

Then optionally wrap it in a Spring @Bean for DI.

4. Important limitation

Wire and protobuf cannot safely coexist for the same .proto in a single module. You must choose one codegen strategy per service contract.

Mixing com.google.protobuf messages and Wire messages will break type compatibility even though the wire protocol is the same.

Tradeoffs

Spring gRPC (protobuf) is more mature and fully integrated with Spring Boot auto-configuration.

Wire gives you:

• Kotlin-native data classes
• Coroutine-based service APIs
• Cleaner client/server symmetry

But requires:

• Manual Spring bridging
• Experimental server adapters
• More custom wiring overall

Bottom line

Yes, it works with Spring Boot, but only by treating Spring as a runtime container and Wire as the full gRPC abstraction layer. You lose Spring’s automatic gRPC wiring (@ImportGrpcClients, BindableService generation) and replace it with explicit beans and adapters.

It’s a valid architecture, just not a plug-and-play substitution.

[oldergod]

https://github.com/square/wire-grpc-server could generate the BindableService that Spring could use but this repo isn't maintained by the Wire team, and is probably not maintained at all