Skip to main content
Redhat Developers  Logo
  • Products

    Featured

    • Red Hat Enterprise Linux
      Red Hat Enterprise Linux Icon
    • Red Hat OpenShift AI
      Red Hat OpenShift AI
    • Red Hat Enterprise Linux AI
      Linux icon inside of a brain
    • Image mode for Red Hat Enterprise Linux
      RHEL image mode
    • Red Hat OpenShift
      Openshift icon
    • Red Hat Ansible Automation Platform
      Ansible icon
    • Red Hat Developer Hub
      Developer Hub
    • View All Red Hat Products
    • Linux

      • Red Hat Enterprise Linux
      • Image mode for Red Hat Enterprise Linux
      • Red Hat Universal Base Images (UBI)
    • Java runtimes & frameworks

      • JBoss Enterprise Application Platform
      • Red Hat build of OpenJDK
    • Kubernetes

      • Red Hat OpenShift
      • Microsoft Azure Red Hat OpenShift
      • Red Hat OpenShift Virtualization
      • Red Hat OpenShift Lightspeed
    • Integration & App Connectivity

      • Red Hat Build of Apache Camel
      • Red Hat Service Interconnect
      • Red Hat Connectivity Link
    • AI/ML

      • Red Hat OpenShift AI
      • Red Hat Enterprise Linux AI
    • Automation

      • Red Hat Ansible Automation Platform
      • Red Hat Ansible Lightspeed
    • Developer tools

      • Red Hat Trusted Software Supply Chain
      • Podman Desktop
      • Red Hat OpenShift Dev Spaces
    • Developer Sandbox

      Developer Sandbox
      Try Red Hat products and technologies without setup or configuration fees for 30 days with this shared Openshift and Kubernetes cluster.
    • Try at no cost
  • Technologies

    Featured

    • AI/ML
      AI/ML Icon
    • Linux
      Linux Icon
    • Kubernetes
      Cloud icon
    • Automation
      Automation Icon showing arrows moving in a circle around a gear
    • View All Technologies
    • Programming Languages & Frameworks

      • Java
      • Python
      • JavaScript
    • System Design & Architecture

      • Red Hat architecture and design patterns
      • Microservices
      • Event-Driven Architecture
      • Databases
    • Developer Productivity

      • Developer productivity
      • Developer Tools
      • GitOps
    • Secure Development & Architectures

      • Security
      • Secure coding
    • Platform Engineering

      • DevOps
      • DevSecOps
      • Ansible automation for applications and services
    • Automated Data Processing

      • AI/ML
      • Data Science
      • Apache Kafka on Kubernetes
      • View All Technologies
    • Start exploring in the Developer Sandbox for free

      sandbox graphic
      Try Red Hat's products and technologies without setup or configuration.
    • Try at no cost
  • Learn

    Featured

    • Kubernetes & Cloud Native
      Openshift icon
    • Linux
      Rhel icon
    • Automation
      Ansible cloud icon
    • Java
      Java icon
    • AI/ML
      AI/ML Icon
    • View All Learning Resources

    E-Books

    • GitOps Cookbook
    • Podman in Action
    • Kubernetes Operators
    • The Path to GitOps
    • View All E-books

    Cheat Sheets

    • Linux Commands
    • Bash Commands
    • Git
    • systemd Commands
    • View All Cheat Sheets

    Documentation

    • API Catalog
    • Product Documentation
    • Legacy Documentation
    • Red Hat Learning

      Learning image
      Boost your technical skills to expert-level with the help of interactive lessons offered by various Red Hat Learning programs.
    • Explore Red Hat Learning
  • Developer Sandbox

    Developer Sandbox

    • Access Red Hat’s products and technologies without setup or configuration, and start developing quicker than ever before with our new, no-cost sandbox environments.
    • Explore Developer Sandbox

    Featured Developer Sandbox activities

    • Get started with your Developer Sandbox
    • OpenShift virtualization and application modernization using the Developer Sandbox
    • Explore all Developer Sandbox activities

    Ready to start developing apps?

    • Try at no cost
  • Blog
  • Events
  • Videos

Autowire MicroProfile into Spring with Quarkus

October 2, 2019
John Clingan
Related topics:
Spring BootQuarkus

Share:

    Eclipse MicroProfile and Spring Boot are often thought of as separate and distinct APIs when developing Java microservices. Developers default to their mental muscle memory by leveraging the APIs that they use on a daily basis. Learning new frameworks and runtimes can be a significant time investment. This article aims to ease the introduction to some popular MicroProfile APIs for Spring developers by enabling them to utilize the Spring APIs they already know while benefiting from significant new capabilities offered by Quarkus.

    More specifically, this article covers the scope and details of the Spring APIs supported by Quarkus so Spring developers have a grasp of the foundation they can build on with MicroProfile APIs. The article then covers MicroProfile APIs that Spring developers will find helpful in the development of microservices. Only a subset of MicroProfile is covered.

    Why Quarkus? Live coding is one reason, where any change is automatically reloaded whether MicroProfile, Spring, or any other Java API. Just run mvn quarkus:dev. That's it. A second compelling reason is that the example project's Person service, which compiles Spring, MicroProfile, and JPA APIs to a native binary using GraalVM's native-image, starts in 0.055 seconds and uses ~90MB of RAM (RSS) after hitting the application RESTful endpoints. Run mvn package -Pnative to compile to a native binary. That's it.

    This article will not go into detailed comparisons, but should give the Spring developers an understanding of how the Spring and MicroProfile APIs can be used together with Quarkus.

    Containers and Kubernetes

    This article will only cover Kubernetes support at a high level to keep this article short(er), but it is important to briefly discuss. One of the Quarkus key value propositions is "Kubernetes-native Java," where the goal is to minimize the memory footprint and reduce the startup time. The reduced memory footprint helps drive up the density of applications on the same hardware, reducing overall costs.

    Quarkus also supports auto-generation of a Kubernetes resources, and guides are available on deploying to Kubernetes and Red Hat OpenShift as well. Additionally, a Dockerfile.jvm (JVM packaging) and Dockerfile.native (native binary packaging) are generated automatically for container creation.

    Last, given that Quarkus considers Kubernetes a target deployment environment, it forgoes using Java frameworks when inherent Kubernetes capabilities are available. Table 1 briefly maps Java frameworks typically used by Spring developers with Kubernetes built-in capabilities.

    Table 1: Java framework to Kubernetes mapping

    Service, Replication Controller("server side")

    Capability Traditional Spring Boot Kubernetes
    Service discovery Eureka DNS
    Configuration Spring Cloud Config Config Maps / Secrets
    Load balancing Ribbon ("client side") Service, Replication Controller("server side")

    Compiling and running the example code

    This article is accompanied by an example project that utilizes Spring and MicroProfile APIs together in the same project, and even the same Java class. The code can be compiled and run from the command line. Be sure to read the README.md for instructions.

    Spring Framework APIs

    Dependency Injection

    Quarkus supports many Contexts and Dependency Injection (CDI) APIs and Spring Dependency Injection (Spring DI) APIs. MicroProfile, Java EE, and Jakarta EE developers will be very familiar with CDI. Spring developers, on the other hand, can use the Quarkus Extension for Spring DI API for Spring DI compatibility. Table 2 covers a sample of the supported Spring DI APIs.

    The example project utilizes both CDI and Spring Dependency Injection, and the Quarkus Spring DI Guide goes into greater detail along with additional examples.

    Table 2: Sample of supported Spring DI APIs

    Spring DI
    Supported Feature

    Examples
    Constructor Injection
    public PersonSpringController(
       PersonSpringRepository personRepository,  // injected      
       PersonSpringMPService personService) {    // injected
          this.personRepository = personRepository;
          this.personService = personService;
    }
    Field Injection
    @Autowired
    @Value
    @Autowired
    @RestClient
    SalutationRestClient salutationRestClient;
    
    @Value("${fallbackSalutation}")
    String fallbackSalutation;
    @Bean
    @Configuration
    @Configuration
    public class AppConfiguration {
       @Bean(name = "capitalizeFunction")
       public StringFunction capitalizer() {
          return String::toUpperCase;
       }
    }
    @Component
    @Component("noopFunction")
    public class NoOpSingleStringFunction implements StringFunction {
       @Override
       public String apply(String s) {
          return s;
       }
    }
    @Service
    @Service
    public class MessageProducer {
       @Value("${greeting.message}")
       String message;
    
       public String getPrefix() {
          return message;
       }
    }

    Web framework

    MicroProfile developers will be comfortable with the Quarkus support for JAX-RS, MicroProfile Rest Client, JSON-P and JSON-B as the core web programming model. Spring developers may be surprised to know that Quarkus has recently added Spring Web API support, specifically around Spring REST-related APIs. As with Spring DI, the goal of Spring Web API support is to make Spring developers feel at home using Spring Web API and MicroProfile APIs together. Table 3 covers a sample of supported Spring Web APIs.

    The example project utilizes Spring Web and MicroProfile Rest Client APIs, and the Quarkus Spring Web Guide goes into greater detail along with additional examples.

    Table 3: Sample of supported Spring Web APIs

    Spring Web
    Supported Feature

    Examples
    @RestController
    @RequestMapping
    @RestController
    @RequestMapping("/person")
    public class PersonSpringController {
       ...
       ...
       ...
    }
    @GetMapping
    @PostMapping
    @PutMapping
    @DeleteMapping
    @PatchMapping
    @RequestParam
    @RequestHeader
    @MatrixVariable
    @PathVariable
    @CookieValue
    @RequestBody
    @ResponseStatus
    @ExceptionHandler
    @RestControllerAdvice (partial)
    @GetMapping(path = "/greet/{id}",
       produces = "text/plain")
       public String greetPerson(
       @PathVariable(name = "id") long id) {
       ...
       ...
       ...
    }

    Spring Data JPA

    MicroProfile developers will be comfortable with the Quarkus JPA support using Hibernate ORM. Spring developers, have no fear! Quarkus has support for commonly used Spring Data JPA annotations and types. Table 4 covers a sample of supported Spring Data JPA APIs.

    The example project utilizes the Spring Data JPA repository APIs, and the Quarkus Spring Data JPA Guide goes into greater detail along with additional examples.

    Table 4: Sample of supported Spring Data JPA APIs

    Spring Data JPA
    Supported Feature

    Examples
    CrudRepository
    public interface PersonRepository
             extends JpaRepository,
                     PersonFragment {
       ...
    }
    Repository

    JpaRepository

    PagingAndSortingRepository

    public class PersonRepository extends 
    
        Repository {
    
        Person save(Person entity);
    
        Optional findById(Person entity);
    }
    Repository Fragments
    public interface PersonRepository
             extends JpaRepository,
                     PersonFragment {
       ...
    }
    Derived query methods

     

    public interface PersonRepository extends CrudRepository {
    
        List findByName(String name);
        
        Person findByNameBySsn(String ssn);
        
        Optional 
           findByNameBySsnIgnoreCase(String ssn);
    
        Boolean existsBookByYearOfBirthBetween(
                Integer start, Integer end);
    }
    User-defined queries
    public interface MovieRepository
             extends CrudRepository {
    
        Movie findFirstByOrderByDurationDesc();
    
        @Query("select m from Movie m where m.rating = ?1")
        Iterator findByRating(String rating);
    
        @Query("from Movie where title = ?1")
        Movie findByTitle(String title);
    }

    MicroProfile APIs

    Fault tolerance

    Fault tolerance patterns are critical to prevent cascading failures and to create a reliable microservice architecture. Hystrix circuit-breaking has been a "go-to" fault tolerance pattern for Spring developers for years. However, Hystrix is in maintenance mode. MicroProfile Fault Tolerance is in active development and developers have been using it in production for years now. Quarkus recommends using MicroProfile Fault Tolerance APIs to improve service reliability. Table 5 covers a sample of the MicroProfile Fault Tolerance APIs.

    The example project uses the MicroProfile Fault Tolerance API, @Timeout and @Fallback in particular. The Quarkus Fault Tolerance Guide goes into greater detail along with additional examples.

    Table 5: Sample of MicroProfile Fault Tolerance APIs

    MicroProfile Fault Tolerance
    Feature

    Description Examples
    @Asynchronous Execute logic on a separate thread
    @Asynchronous
    @Retry
    public Future<String> getSalutation() {
       ...
       return future;
    }
    @Bulkhead Limits number of concurrent requests
    @Bulkhead(5)
    public void fiveConcurrent() {
       makeRemoteCall(); //...
    }
    @CircuitBreaker Gracefully handle faults and fault recovery
    @CircuitBreaker(delay=500   // milliseconds
       failureRatio = .75,
       requestVolumeThreshold = 20,
       successThreshold = 5)
    @Fallback(fallbackMethod = "fallback")
    public String getSalutation() {
       makeRemoteCall(); //...
    }
    @Fallback Alternative logic called upon failure
    @Timeout(500) // milliseconds
    @Fallback(fallbackMethod = "fallback")
    public String getSalutation() {
       makeRemoteCall(); //...
    }
    
    public String fallback() {
       return "hello";
    }
    
    
    @Retry Retry a request
    @Retry(maxRetries=3)
    public String getSalutation() {
       makeRemoteCall(); //...
    }
    @Timeout Wait period before assuming failure
    @Timeout(value = 500 )   // milliseconds
    @Fallback(fallbackMethod = "fallback")
    public String getSalutation() {
       makeRemoteCall(); //...
    }

    Service Health

    Platforms like Kubernetes utilize probes to check the health of a container. Spring developers utilize a custom HealthIndicator and Spring Boot Actuator to expose the health of a service to the underlying platform. With Quarkus, Spring developers can utilize MicroProfile Health to expose the health of a service. A default liveness check is provided, and developers can provide custom liveness and readiness checks as well. Table 6 covers a sample of the MicroProfile Health APIs.

    The example project uses MicroProfile Health to expose the readiness of an application. The Quarkus Health Guide goes into greater detail along with additional examples.

    Table 6: Sample of MicroProfile Health APIs

    MicroProfile Health
    Feature

    Description Examples
    @Liveness Platform will reboot unhealthy containerized applications.

    Endpoint:
    host:8080/health/live

    @Liveness
    public class MyHC implements HealthCheck {
      public HealthCheckResponse call() {
    
       ...
       return HealthCheckResponse
         .named("myHCProbe")
         .status(ready ? true:false)
         .withData("mydata", data)
         .build();  
    }
    @Readiness Platform will not direct traffic to containerized applications that are not ready.

    Endpoint:
    host:8080/health/ready

    @Readiness
    public class MyHC implements HealthCheck {
      public HealthCheckResponse call() {
    
       ...
       return HealthCheckResponse
         .named("myHCProbe")
         .status(live ? true:false)
         .withData("mydata", data)
         .build();  
    }

    Metrics

    Applications expose metrics for operational reasons (like performance SLAs) and non-operational reasons (like business SLAs). Spring developers typically utilize Spring Boot Actuator and Micrometer to expose metrics. Quarkus utilizes MicroProfile Metrics to expose base (JVM & Operating System), Vendor (Quarkus), and application metrics. MicroProfile Metrics requires JSON and OpenMetrics (Prometheus) output formats be supported by implementations. Table 7 covers a sample of the MicroProfile Metrics APIs.

    The example project uses MicroProfile Metrics to expose the application metrics. The Quarkus Metrics Guide goes into greater detail along with additional examples.

    Table 7: Sample of MicroProfile Metrics APIs

    MicroProfile Metrics
    Feature

    Description Examples
    @Counted Denotes a counter which counts the invocations of the annotated object.
    @Counted(name = "fallbackCounter", 
      displayName = "Fallback Counter", 
      description = "Fallback Counter")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    @ConcurrentGauge Denotes a gauge which counts the parallel invocations of the annotated object.
    @ConcurrentGuage(
      name = "fallbackConcurrentGauge", 
      displayName="Fallback Concurrent", 
      description="Fallback Concurrent")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    @Gauge Denotes a gauge, which samples the
    value of the annotated object.
    @Metered(name = "FallbackGauge",
       displayName="Fallback Gauge",
       description="Fallback frequency")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    @Metered Denotes a meter which tracks the frequency of invocations of the annotated object.
    @Metered(name = "MeteredFallback",
       displayName="Metered Fallback",
       description="Fallback frequency")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    @Metric An annotation that contains the metadata
    information when requesting a metric to
    be injected or produced.
    @Metric
    @Metered(name = "MeteredFallback",
       displayName="Metered Fallback",
       description="Fallback frequency")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    @Timed Denotes a timer which tracks duration of
    the annotated object.
    @Timed(name = "TimedFallback",
       displayName="Timed Fallback",
       description="Fallback delay")
    public String salutationFallback() {
       return fallbackSalutation;
    }
    Metrics Endpoints
    Application metrics http://localhost:8080/metrics/application
    Base metrics http://localhost:8080/metrics/base
    Vendor metrics http://localhost:8080/metrics/vendor
    All metrics http://localhost:8080/metrics

    MicroProfile Rest Client

    Microservices often expose RESTful endpoints, requiring a client API to consume a RESTful endpoint. Spring developers typically use a RestTemplate to consume RESTful endpoints. Quarkus supports the MicroProfile Rest Client API to do the same. Table 8 covers a sample of MicroProfile Rest Client APIs.

    The example project uses MicroProfile Rest Client to consume RESTful endpoints. The Quarkus Rest Client Guide goes into greater detail along with additional examples.

    Table 8: Sample of MicroProfile Rest Client APIs

    MicroProfile
    Rest Client
    Feature
    Description Examples
    @RegisterRestClient Register a typed Java interface as a REST client
    @RegisterRestClient
    @Path("/")
    public interface MyRestClient {
        @GET
        @Produces(MediaType.TEXT_PLAIN)
        public String getSalutation();
    }
    @RestClient Decorate  instance injection of a typed REST client interface
    @Autowired // or @Inject
    @RestClient
    MyRestClient restClient;
    Invocation Invoke REST endpoint
    System.out.println(
       restClient.getSalutation());
    mp-rest/url Specify rest endpoint
    application.properties:
    org.example.MyRestClient/mp-rest/url=
       http://localhost:8081/myendpoint

    Summary

    This article provided an overview, primarily for Spring developers, on using Spring APIs together and MicroProfile APIs with Quarkus. Spring developers can now use some of the APIs they know and love, combined with MicroProfile APIs, to live code Java microservices and then compile them to a native binary savings 100's of MB of RAM while starting in milliseconds.

    Note: The Quarkus guides provide more details around Spring and MicroProfile API support, and much more.

    Last updated: July 1, 2020

    Recent Posts

    • Exploring Llama Stack with Python: Tool calling and agents

    • Enhance data security in OpenShift Data Foundation

    • AI meets containers: My first step into Podman AI Lab

    • Live migrating VMs with OpenShift Virtualization

    • Storage considerations for OpenShift Virtualization

    Red Hat Developers logo LinkedIn YouTube Twitter Facebook

    Products

    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform

    Build

    • Developer Sandbox
    • Developer Tools
    • Interactive Tutorials
    • API Catalog

    Quicklinks

    • Learning Resources
    • E-books
    • Cheat Sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site Status Dashboard
    • Report a security problem

    RED HAT DEVELOPER

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2025 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility

    Report a website issue