This page lists the Java libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).

The test catalog also holds 8 look-alike cases for Java: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.

Web frameworks and HTTP servers (the routes your code serves)

18 supported, 1 partly, 3 not yet.

Name Status Ways of using it that were tested
Armeria partly yes: annotated service @Get(path) / @Post(path)
no: Server.builder().service(path, (ctx, req) -> ...)
AWS SAM template.yaml supported yes: AWS::Serverless::Function (Runtime java17, Handler package.Class::method or package.Class) with Events Type HttpApi or Api Path and Method
Azure Functions (Java) supported yes: @FunctionName("X") method with a parameter annotated @HttpTrigger(methods = {HttpMethod.GET}, route = "x/{id}"), served under the host.json routePrefix
yes: @HttpTrigger with no route and no methods: the route is the @FunctionName name and every verb
Eclipse Jetty (embedded) supported yes: ServletContextHandler.addServlet(holder or class, pattern)
Helidon SE 4 supported yes: HttpRouting.Builder.get(path, handler).post(path, lambda)
Javalin supported yes: app.get(path, lambda) / app.post(path, Class::method)
yes: ApiBuilder path(prefix, () -> { get(h); post(sub, h); }) in config.router.apiBuilder
JAX-RS (jakarta.ws.rs: Jersey, RESTEasy, Quarkus REST) supported yes: @Path on class and method, @GET/@POST/@DELETE
JAX-RS (javax.ws.rs: Dropwizard, Java EE 8) supported yes: @Path / @GET / @PUT in the javax namespace
Jooby not yet no: get(path, ctx -> ...) inside the Jooby subclass initialiser
Micronaut HTTP supported yes: @Controller(prefix) with @Get(path) and @Post (no path)
Play Framework (Java) not yet no: conf/routes lines: VERB path controllers.X.method()
Quarkus reactive routes supported yes: @RouteBase(path) + @Route(path, methods)
Quarkus REST (RESTEasy Reactive) supported yes: plain JAX-RS @Path/@GET in a Quarkus app
Ratpack supported yes: chain.get(path, handler) with no leading slash
yes: chain.prefix(prefix, sub -> sub.post(path, handler))
Serverless Framework serverless.yml supported yes: functions.<name>.handler package.Class[::method] with events httpApi or http
Spark Java supported yes: static get(path, (req, res) -> ...) and Spark.post(...)
Spring Boot supported yes: new ServletRegistrationBean<>(new XServlet(), path)
Spring Web MVC supported yes: @RestController + class @RequestMapping prefix + @GetMapping/@PostMapping/@PutMapping/@DeleteMapping
yes: @RequestMapping(path = {a, b}, method = RequestMethod.POST) on @Controller + @ResponseBody
yes: mapping path held in a static final String constant
Spring WebFlux supported yes: annotated @RestController returning Mono
Spring WebFlux (functional) supported yes: RouterFunctions.route().GET(path, handler).POST(...).build()
yes: static route(GET(path), handler) from RequestPredicates
yes: nest(path(prefix), route(GET(sub), handler))
Undertow not yet no: Handlers.routing().get(path, handler).post(path, lambda)
Vert.x Web supported yes: router.get(path).handler(h) / router.post(path).handler(lambda)
yes: router.route(HttpMethod.X, path).handler(h)

The language's own HTTP server

3 supported, 0 partly, 1 not yet.

Name Status Ways of using it that were tested
com.sun.net.httpserver (JDK) supported yes: HttpServer.createContext(path, lambda)
yes: createContext(path, new XHandler()) with a class implementing HttpHandler
yes: createContext(path, Class::method), verb read inside from getRequestMethod()
yes: HttpsServer.createContext
Servlet API (jakarta.servlet) supported yes: @WebServlet("/path") on an HttpServlet subclass, verbs from doGet/doPost
yes: @WebServlet(name=, urlPatterns={a, b})
yes: ServletContext.addServlet(name, X.class).addMapping(path)
Servlet API (javax.servlet) supported yes: @WebServlet(urlPatterns = ...) in the old javax namespace
Servlet API (WEB-INF/web.xml) not yet no: <servlet-mapping> url-pattern naming a servlet-class

HTTP client libraries (the calls your code makes to other services)

14 supported, 1 partly, 5 not yet.

Name Status Ways of using it that were tested
Apache HttpClient 4 supported yes: client.execute(new HttpGet/HttpPost/HttpDelete(url))
Apache HttpClient 5 supported yes: client.execute(new HttpGet(url), responseHandler)
Apache HttpClient 5 Fluent supported yes: Request.get(url).execute() / Request.post(url)
AsyncHttpClient supported yes: client.prepareGet(url).execute() / preparePost
Google HTTP Client not yet no: factory.buildGetRequest(new GenericUrl(url)).execute()
JAX-RS client (Jersey, RESTEasy) supported yes: ClientBuilder.newClient().target(base).path(p).request().get()/post()
Jetty HttpClient supported yes: httpClient.GET(url) / newRequest(url).method(..).send()
Micronaut HTTP client not yet no: @Client(base) interface with @Get(path)
MicroProfile REST Client (Quarkus, Open Liberty) supported yes: @RegisterRestClient(baseUri) interface with @Path + @GET
OkHttp supported yes: client.newCall(new Request.Builder().url(x)[.post(body)].build()).execute()
OpenFeign (plain) not yet no: @RequestLine("VERB /path") with Feign.builder().target(Api.class, base)
Reactor Netty HttpClient supported yes: HttpClient.create().baseUrl(base).get().uri(path)
Retrofit not yet no: interface with @GET/@POST and Retrofit.Builder().baseUrl(base)
Spring Cloud OpenFeign supported yes: @FeignClient(name, url) interface with @GetMapping/@PostMapping
yes: @FeignClient(name = service) with no url (service discovery)
Spring HTTP interface (@HttpExchange) not yet no: interface with @HttpExchange(base) and @GetExchange/@PostExchange
Spring RestClient (6.1+) supported yes: RestClient.create(base).get().uri(path, vars).retrieve().body(T)
Spring RestTemplate supported yes: getForObject(literal url + id, type)
yes: postForEntity(baseUrl from @Value("${...}") + path)
yes: exchange(url template, HttpMethod.PUT, entity, type, vars)
yes: delete(url) and postForObject(url, ...)
Spring WebClient supported yes: WebClient.create(base).get().uri(path, vars).retrieve()
yes: WebClient.builder().baseUrl(base with a path).build() then .uri(sub)
Unirest for Java supported yes: Unirest.get(url with {param}).routeParam(..) / Unirest.post(url)
Vert.x WebClient partly partly: client.get(port, host, path).send()
yes: client.getAbs/postAbs(absolute url).send()

The language's own HTTP client

1 supported, 1 partly, 1 not yet.

Name Status Ways of using it that were tested
java.net.http.HttpClient (JDK 11+) partly partly: send(HttpRequest.newBuilder().uri(URI.create(x)).GET().build(), handler)
yes: sendAsync / send with .POST(BodyPublishers...)
yes: HttpRequest.newBuilder(URI) with no .uri() step
java.net.HttpURLConnection (JDK) not yet no: (HttpURLConnection) new URL(x).openConnection() then setRequestMethod("POST")
no: URI.create(x).toURL().openConnection(), default GET
java.net.URL (JDK) supported yes: new URL(x).openStream()

gRPC

7 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Armeria gRPC supported yes: GrpcService.builder().addService(impl of the generated base)
grpc-java supported yes: class extends {S}Grpc.{S}ImplBase with @Override per RPC (unary, server stream, client stream)
yes: class implements {S}Grpc.AsyncService, BindableService
grpc-java client supported yes: {S}Grpc.newBlockingStub(channel).rpc(req), channel from ManagedChannelBuilder.forAddress/forTarget
yes: non-RPC stub step before the call: stub.withDeadlineAfter(..).rpc(req)
yes: {S}Grpc.newStub(channel).rpc(req, StreamObserver)
yes: {S}Grpc.newFutureStub(channel).rpc(req) returning ListenableFuture
yes: ClientCalls.blockingUnaryCall(channel, {S}Grpc.get{M}Method(), options, req)
grpc-spring-boot-starter (net.devh) supported yes: @GrpcService on a subclass of the generated base
grpc-spring-boot-starter (net.devh) client supported yes: @GrpcClient("name") on a stub field, address in application.yml
LogNet grpc-spring-boot-starter supported yes: @GRpcService on a subclass of the generated base
Quarkus gRPC supported yes: @GrpcService class implements the Mutiny interface {S}, methods return Uni

Databases and data stores

21 supported, 8 partly, 3 not yet.

Name Status Ways of using it that were tested
AWS SDK v2 DynamoDB supported yes: dynamo.getItem(GetItemRequest.builder().tableName(name)...)
AWS SDK v2 DynamoDB Enhanced supported yes: enhanced.table(name, TableSchema.fromBean(..)).getItem
AWS SDK v2 S3 supported yes: s3.putObject(PutObjectRequest.builder().bucket(name)..) / getObjectAsBytes
DataStax Java driver (Cassandra) partly partly: session.execute(CQL string) / SimpleStatement.newInstance(CQL)
Ebean ORM partly partly: DB.find(X.class).where()...findList() / DB.save(x)
Elasticsearch Java client supported yes: client.search(s -> s.index(name)...) / client.index(i -> i.index(name))
Hibernate ORM (native Session) partly partly: session.persist / session.get(X.class, id) / createQuery(HQL)
JDBC (java.sql, JDK) supported yes: DriverManager.getConnection(url) + createStatement().executeQuery(SQL)
yes: conn.prepareStatement(SQL) then executeUpdate/executeQuery
yes: conn.prepareCall("{call proc(?)}")
JDBC (javax.sql.DataSource) supported yes: dataSource.getConnection().createStatement().executeUpdate(SQL)
JDBI 3 supported yes: jdbi.withHandle(h -> h.createQuery(SQL)) / h.execute(SQL)
yes: SqlObject interface with @SqlQuery/@SqlUpdate
Jedis (Redis) partly partly: jedis.get/set on keys, JedisPooled.hincrBy
jOOQ supported yes: dsl.selectFrom(table("name")) / insertInto(table("name"))
yes: dsl.fetch(SQL string, binds)
JPA EntityManager (jakarta.persistence) supported yes: em.persist / em.find(X.class, id) / em.remove
yes: em.createQuery(JPQL naming the entity, X.class)
yes: em.createNativeQuery(SQL).executeUpdate()
Lettuce (Redis) supported yes: RedisClient.create(uri).connect().sync().get(key) / async().expire
Micronaut Data JDBC supported yes: @JdbcRepository interface extends CrudRepository<T, Id>, entity @MappedEntity(name)
MongoDB Java driver partly partly: db.getCollection(name).find / insertOne / deleteMany
MyBatis supported yes: @Mapper interface with @Select/@Insert SQL
yes: mapper XML <select id> bound to an interface method
MyBatis-Plus supported yes: interface extends BaseMapper<T>, entity @TableName, selectList/insert
Neo4j Java driver partly partly: session.run(Cypher, params)
Quarkus Hibernate ORM with Panache not yet no: entity extends PanacheEntity: list(..), persist(), count()
Redisson not yet no: redisson.getMap(name).put / getLock(name)
Spring cache abstraction not yet no: @Cacheable("cache-name") on a method
Spring Data Elasticsearch supported yes: interface extends ElasticsearchRepository<T, Id>, @Document(indexName)
Spring Data JDBC supported yes: interface extends CrudRepository<T, Id>, entity @Table(name) from data.relational
Spring Data JPA supported yes: interface extends JpaRepository<Entity, Id> with derived finders; entity @Table(name)
yes: @Query("SELECT o FROM Entity o ...") on a repository method
yes: @Query(value = SQL, nativeQuery = true)
Spring Data MongoDB partly yes: interface extends MongoRepository<T, Id>, @Document(name)
no: mongoTemplate.find(query, T.class, "collection") / insert(doc, "collection")
Spring Data R2DBC supported yes: interface extends R2dbcRepository<T, Id>, entity @Table(name)
Spring Data Redis partly partly: redisTemplate.opsForValue().get/set, opsForHash().put
Spring JDBC supported yes: jdbcTemplate.queryForList / update(SQL, args)
yes: NamedParameterJdbcTemplate.update(SQL with :names, map)
yes: new SimpleJdbcInsert(jdbc).withTableName(name).execute(map)
Spring JDBC JdbcClient (6.1+) supported yes: jdbcClient.sql(SQL).param(..).query(T).list()
Spring R2DBC DatabaseClient supported yes: client.sql(SQL).fetch()/all()
Vert.x SQL client supported yes: pool.query(SQL).execute() / preparedQuery(SQL).execute(tuple)

Messaging and events (queues, topics, streams)

14 supported, 7 partly, 4 not yet.

Name Status Ways of using it that were tested
Apache Camel not yet no: RouteBuilder.configure(): from("kafka:topic?..").to("jms:queue:name")
Apache Kafka clients supported yes: producer.send(new ProducerRecord<>(topic, key, value))
yes: consumer.subscribe(List.of(topic)) + poll loop
Apache Pulsar client supported yes: client.newProducer().topic(name).create().send(..)
yes: client.newConsumer().topic(name).subscriptionName(..).subscribe()
AWS SDK v2 SNS supported yes: sns.publish(PublishRequest.builder().topicArn(arn)...)
AWS SDK v2 SQS partly yes: sqs.sendMessage(SendMessageRequest.builder().queueUrl(url)...)
no: sqs.receiveMessage(ReceiveMessageRequest.builder().queueUrl(url)...)
Azure Service Bus partly yes: new ServiceBusClientBuilder().sender().queueName(name).buildClient().sendMessage(..)
partly: builder.processor().queueName(name).processMessage(cb)
Eclipse Paho MQTT supported yes: client.publish(topic, msg) / client.subscribe(filter, listener)
Google Cloud Pub/Sub partly yes: Publisher.newBuilder(TopicName.of(project, topic)).build().publish(msg)
no: Subscriber.newBuilder(ProjectSubscriptionName.of(project, sub), receiver)
Jakarta Messaging (JMS) partly partly: class implements MessageListener { onMessage(..) }
Jakarta Messaging (JMS) classic API supported yes: session.createConsumer(session.createQueue(name)).setMessageListener(..)
yes: session.createProducer(session.createQueue(name)).send(msg)
Jakarta Messaging 2.0 simplified API supported yes: context.createConsumer(context.createQueue(name)) / createProducer().send(queue, body)
Java Message Service (javax.jms) supported yes: the classic API in the old javax namespace
Jedis pub/sub supported yes: jedis.publish(channel, msg) / jedis.subscribe(JedisPubSub, channel)
Kafka Streams not yet no: builder.stream(topic) ... .to(topic)
Micronaut Kafka not yet no: @KafkaListener class with @Topic method; @KafkaClient interface with @Topic method
NATS Java client (jnats) supported yes: connection.publish(subject, bytes)
yes: dispatcher.subscribe(subject) / connection.subscribe(subject)
RabbitMQ Java client partly yes: channel.basicPublish("", queue, props, body)
no: channel.basicConsume(queue, autoAck, DeliverCallback, CancelCallback)
no: basicConsume(queue, ack, new DefaultConsumer(ch) { handleDelivery(..) })
SmallRye / MicroProfile Reactive Messaging (Quarkus) not yet no: @Incoming(channel), @Outgoing(channel), @Channel Emitter; channel to topic in application.properties
Spring AMQP (RabbitMQ) partly yes: rabbitTemplate.convertAndSend(routingKey, message) on the default exchange
partly: convertAndSend(exchange, routingKey, message)
yes: @RabbitListener(queues = "literal")
Spring application events (in-process) supported yes: publisher.publishEvent(obj) + @EventListener on the type
Spring Cloud AWS supported yes: @SqsListener("queue-name")
yes: sqsTemplate.send(queue, payload)
Spring Cloud Stream partly no: @Bean Consumer<T> name() bound in application.yml (name-in-0.destination)
partly: streamBridge.send(binding or destination, payload)
Spring Data Redis pub/sub supported yes: redisTemplate.convertAndSend(channel, msg) / container.addMessageListener(l, new ChannelTopic(ch))
Spring for Apache Kafka supported yes: kafkaTemplate.send(topic, [key,] value)
yes: @KafkaListener(topics = "literal")
yes: @KafkaListener(topics = "${property}") resolved from application.yml
Spring JMS supported yes: jmsTemplate.convertAndSend(destination, payload)
yes: @JmsListener(destination = "literal")

Build tools and package managers

19 supported, 1 partly, 0 not yet.

Name Status Ways of using it that were tested
Apache Ant supported yes: root build.xml calling <ant dir=...> per module; flat src/ folders; Main-Class in the jar manifest
Apache Ant + Ivy supported yes: ivy.xml per module naming the other module as a dependency, ivysettings.xml at the root
Bazel (Bzlmod, MODULE.bazel) supported yes: MODULE.bazel with bazel_dep, BUILD.bazel files loading rules_java
Bazel (WORKSPACE) supported yes: WORKSPACE at the root, BUILD per package with java_binary, java_library and java_test
Bndtools workspace (OSGi) supported yes: cnf/ plus one folder per bundle with bnd.bnd and flat src/
Gradle (Groovy DSL) supported yes: settings.gradle include, application and Spring Boot services, java-library module, project(':x') dependency
Gradle (Kotlin DSL) supported yes: settings.gradle.kts include(...), java-library and Spring Boot plugin, implementation(project(":x"))
Gradle buildSrc supported yes: buildSrc with a precompiled convention plugin applied by id
Gradle composite build supported yes: includeBuild("platform/money") with the dependency by coordinates, substituted by Gradle
Gradle included build for convention plugins supported yes: pluginManagement { includeBuild("build-logic") } with a Plugin<Project> class; the service applies id("shop.service")
Gradle version catalog supported yes: gradle/libs.versions.toml, alias(libs.plugins.x) and typesafe project accessors implementation(projects.moneyLib)
Gradle war plugin supported yes: id 'war' with src/main/webapp/WEB-INF/web.xml
Gradle Wrapper supported yes: gradlew, gradlew.bat and gradle/wrapper next to a multi-project build
Maven supported yes: one pom.xml, src/main/java and src/test/java, target/ output
yes: reactor: parent pom packaging pom with <modules>, two Spring Boot services and a jar library
yes: <modules> nested two deep: root -> platform (pom) -> libraries, root -> apps (pom) -> service
yes: BOM import (scope import, type pom), a local BOM module, and a module listed only inside a <profile>
Maven (ear packaging) supported yes: an ear module packaging an ejb module and a war module
Maven (war packaging) supported yes: packaging war with src/main/webapp/WEB-INF/web.xml and no main method
Maven + maven-bundle-plugin (OSGi) supported yes: packaging bundle; one bundle exports a package, one has a Bundle-Activator
Maven + Quarkus supported yes: quarkus-maven-plugin service with no main method, plus a jar library
Maven Wrapper supported yes: mvnw, mvnw.cmd and .mvn/wrapper next to a reactor
sbt partly partly: build.sbt with project.in(file(..)), dependsOn and aggregate; Java and Scala in one module

Project and folder layouts

11 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Gradle (Groovy DSL) supported yes: project(':x').projectDir = file('other/folder') in settings.gradle
Gradle (Kotlin DSL) supported yes: include("services:orders") with colon paths mapping to nested folders
Gradle + Micronaut supported yes: io.micronaut.application service and io.micronaut.library library
Gradle + Spring Boot supported yes: a shared library applying the Spring Boot plugin with bootJar disabled
Gradle test source sets supported yes: src/test, src/integrationTest (jvm-test-suite), src/testFixtures, and a test-only module
Gradle with custom sourceSets supported yes: srcDirs = ['src'] and ['test'] instead of src/main/java
Java Platform Module System supported yes: module-info.java in each module (exports / requires)
javac + jar (no build tool) supported yes: flat src/ with packages, a MANIFEST.MF Main-Class and a shell script
Maven supported yes: aggregator pom in a subfolder listing ../sibling modules (flat multi-module)
Maven or Gradle output folders supported yes: target/, build/, out/ (IntelliJ), bin/ (Eclipse), .gradle/, .idea/ next to real source
yes: target/, build/, out/ (IntelliJ), bin/ (Eclipse), .gradle/, .idea/ next to real source, with no .gitignore
niro-local (way of adding a repository) supported yes: one niro-local init at the repository root; a root docker-compose.yml names each service with build:
yes: each service folder and the caller added one by one with niro-local init --project <same>
yes: each service is its own git checkout inside one parent folder; one niro-local init at the parent
yes: only the caller folder is added; the services it calls are not in the project
yes: one niro-local init at the root of a Maven reactor with no deploy descriptor