# Supported in Java

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

**What the marks mean.**

- **Supported:** Niro recognised every way of using it that the test code tries.

- **Partly:** Niro recognised some of those ways, or recognised one only in part.

- **Not yet:** Niro did not recognise it in the test code.

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](https://help.niroai.dev/cli/coverage-audit-and-consent/)).

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 |