Ola a todos, aquí tedes a terceira publicación da serie Quarkus!
Ao desenvolver microservizos Java, adoita crer que и son API separadas e independentes. Por defecto, os programadores tenden a usar as API ás que xa están afeitos, xa que aprender novos frameworks e compoñentes de execución leva moito tempo. Hoxe trataremos de simplificar o desenvolvemento dalgúns populares e mostrarche como usar simultaneamente a API Spring e novas funcións útiles .
Con un pouco máis de detalle, primeiro analizaremos o alcance e os detalles de como Quarkus admite as API de Spring para mostrarlles aos desenvolvedores de Spring como usar a API de MicroProfile no seu traballo diario. Despois trataremos as API de MicroProfile, que son útiles para os desenvolvedores de Spring á hora de crear microservizos.
Por que Quarkus? En primeiro lugar, trátase de codificación en directo, é dicir, a recarga automática de calquera cambio na API MicroProfile, na API Spring e noutras API de Java, que se realiza cun só comando: mvn quarkus:dev. En segundo lugar, considerado en o servizo Person (que compila a partir das API Spring, MicroProfile e JPA nun binario usando a imaxe nativa de GraalVM) comeza en só 0.055 segundos e ocupa uns 90 MB de RAM (RSS) no punto final da aplicación RESTful. Ademais, a súa propia compilación realízase cun só comando: mvn package -Pnative.
Non entraremos en detalles sobre MicroProfile, salvo para axudar aos desenvolvedores de Spring a comprender como poden usar as API de Spring coas API de MicroProfile en Quarkus.
Contedores e Kubernetes
Para que este artigo sexa sinxelo, só cubriremos os aspectos de alto nivel do soporte aquí. , porque é importante entender. Quarkus sitúase como unha pila Java para Kubernetes, está deseñado para minimizar o consumo de memoria e o tempo de inicio das aplicacións e servizos Java e, como resultado, aumentar a súa densidade no servidor e reducir os custos xerais.
Quarkus tamén Recursos e ofertas de Kubernetes para a súa implantación en plataformas Kubernetes e Red Hat OpenShift. Ademais, Quarkus xera automaticamente os ficheiros Dockerfile.jvm (embalaxe JVM) e Dockerfile.native (envase binario nativo) necesarios para crear contedores.
Finalmente, ao centrarse en Kubernetes como o contorno de implantación de destino, Quarkus non utiliza marcos Java nos casos en que se implemente unha funcionalidade similar a nivel da propia plataforma Kubernetes. A táboa 1 ofrece un mapa da correspondencia funcional entre Kubernetes e os frameworks Java típicos utilizados polos desenvolvedores de Spring.
Táboa 1. Mapa de correspondencia funcional entre frameworks Java e Kubernetes.
Funcional
Bota de primavera tradicional
Kubernetes
Descubrimento do servizo
Eureka
DNS
configuración
Configuración de Spring Cloud
Configurar mapas/segredos
Equilibrado de carga
Cinta (lado cliente)
Servizo, controlador de replicación (lado do servidor)
Compilación e execución do código do exemplo
Neste artigo nos referimos , onde se usan conxuntamente as API Spring e MicroProfile e mesmo a mesma clase Java. O código deste exemplo pódese compilar e executar desde a liña de comandos; consulte o ficheiro README.md para obter máis información.
API de Spring Framework
Inxección de dependencia
Quarkus admite unha variedade de e API de Spring Dependency Injection (Spring DI). Se está a traballar con MicroProfile, , entón xa estás moi familiarizado co CDI. Por outra banda, os desenvolvedores de Spring poden usar a API de Quarkus Extension for Spring DI para lograr a compatibilidade con Spring DI. Na táboa 2 móstranse exemplos de uso das API Spring DI compatibles.
В Usa CDI e Spring Dependency Injection. Para obter máis información e exemplos sobre este tema, consulte a guía de Quarkus chamada .
Táboa 2. Exemplos de uso das API Spring DI compatibles.
Características Spring DI admitidas
Exemplos
Inxección Constructora
public PersonSpringController(
PersonSpringRepository personRepository, // injected
PersonSpringMPService personService) { // injected
this.personRepository = personRepository;
this.personService = personService;
}
Inxección de campo
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@Configuración
@Configuration
public class AppConfiguration {
@Bean(name = "capitalizeFunction")
public StringFunction capitalizer() {
return String::toUpperCase;
}
}
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
@Override
public String apply(String s) {
return s;
}
}
@Service
public class MessageProducer {
@Value("${greeting.message}")
String message;
public String getPrefix() {
return message;
}
}
Marco web
Os usuarios de MicroProfile encantarán que Quarkus admita JAX-RS, MicroProfile Rest Client, JSON-P e JSON-B como modelo de programación web principal. Os desenvolvedores de Spring estarán satisfeitos co soporte recente de Quarkus para a API Spring Web, en particular as interfaces REST. Do mesmo xeito que Spring DI, o obxectivo principal da compatibilidade das API de Spring Web é permitir que os desenvolvedores de Spring utilicen as API de Spring Web xunto coas API de MicroProfile. Na Táboa 3 ofrécense exemplos de como usar as API de Spring Web compatibles, e pódese atopar máis información e exemplos sobre este tema no tutorial de Quarkus chamado .
Táboa 3. Exemplos de uso das API Spring Web compatibles.
Funcións web de Spring admitidas
Exemplos
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (parcial)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Spring DataJPA
Os usuarios de MicroProfile tamén apreciarán que Quarkus admite JPA usando o Hibernate ORM. Tamén hai boas noticias para os desenvolvedores de Spring: Quarkus admite anotacións e tipos JPA de Spring Data comúns. Na táboa 4 móstranse exemplos de uso das API JPA de Spring Data compatibles.
В Utilízanse as API Spring Data JPA e hai máis información dispoñible no tutorial de Quarkus chamado .
Táboa 4. Exemplos de uso das API JPA de Spring Data compatibles.
Características JPA de Spring Data admitidas
Exemplos
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repositorio
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Fragmentos de repositorio
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Métodos de consulta derivados
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Consultas definidas polo usuario
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);
}
API de MicroProfile
Tolerancia a fallos
As construcións de tolerancia a fallos son moi importantes para evitar fallos en cascada e crear arquitecturas de microservizos fiables. Os desenvolvedores de resortes levan moitos anos usando interruptores automáticos para tolerar fallos. . Non obstante, Hystrix non se actualizou desde hai moito tempo, pero a tolerancia a fallos de MicroProfile está agora a desenvolverse activamente e ten varios anos de uso na produción detrás. Polo tanto, para mellorar a fiabilidade dos servizos en Quarkus, recoméndase utilizar as API de tolerancia a fallos de MicroProfile, cuxos exemplos se usan na Táboa 5. Para obter máis información sobre isto, consulte o manual de Quarkus .
Táboa 5. Exemplos de uso das API de tolerancia a fallos de MicroProfile compatibles.
Características de tolerancia a fallos de MicroProfile
Descrición
Exemplos
@Asincrónico
Execución da lóxica nun fío separado
@Asynchronous
@Retry
public Future<String> getSalutation() {
...
return future;
}
@Mamparo
Limitar o número de solicitudes simultáneas
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@Interruptor
Manexo intelixente de fallos e recuperación de fallos
@CircuitBreaker(delay=500 // milliseconds
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Fallback
Chamar a lóxica alternativa en caso de fallo
@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Volve tentar se falla a solicitude
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Tempo de espera do control de fallos
@Timeout(value = 500 ) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Servizos de comprobación (Saúde do servizo)
As plataformas Kubernetes supervisan a saúde dos contedores mediante servizos especiais. Para permitir que a plataforma subxacente supervise os servizos, os desenvolvedores de Spring normalmente usan un HealthIndicator e un Spring Boot Actuator personalizados. En Quarkus, isto pódese facer mediante MicroProfile Health, que de forma predeterminada realiza unha comprobación de vivacidade, pero pódese configurar para verificar simultaneamente a vitalidade e a preparación. Na Táboa 6 ofrécense exemplos de como usar as API de MicroProfile Health compatibles, e a información adicional no manual de Quarkus. .
Táboa 6: exemplos de uso das API de MicroProfile Health compatibles.
Características de MicroProfile Health
Descrición
Exemplos
@Vividade
A plataforma reinicia as aplicacións en contedores que fallaron
Punto final:
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();
}
@Preparación
A plataforma non enviará tráfico a aplicacións en contedores se non está lista
Punto final:
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();
}
Métricas
As aplicacións proporcionan métricas para fins operativos (para supervisar os SLA de rendemento) ou para fins non operativos (SLA comerciais). Os desenvolvedores de Spring proporcionan métricas usando Spring Boot Actuator e Micrometer. Pola súa banda, Quarkus usa MicroProfile Metrics para proporcionar métricas de referencia (JVM e sistema operativo), métricas de provedores (Quarkus) e métricas de aplicación. MicroProfile Metrics require que a implementación admita os formatos de saída JSON e OpenMetrics (Prometheus). Na Táboa 7 móstranse exemplos de uso da API MicroProfile Metrics.
В As métricas de MicroProfile úsanse para proporcionar métricas de aplicación. Para obter máis información, consulte o manual de Quarkus .
Táboa 7. Exemplos de uso das API de MicroProfile Metrics.
Características de MicroProfile Metrics
Descrición
Exemplos
@Contado
Indica un contador que conta o número de veces que se chamou a un obxecto anotado
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Indica un indicador que conta o número de chamadas simultáneas a un obxecto anotado
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Gauge
Indica un sensor indicador que mide o valor dun obxecto anotado
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@medido
Indica un sensor de medidor que supervisa a frecuencia de chamada dun obxecto anotado
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Unha anotación que contén información sobre metadatos cando se recibe unha solicitude para introducir ou producir unha métrica
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Indica un temporizador que rastrexa a duración dun obxecto anotado
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Puntos finais de métricas
Métricas de aplicación :8080/metrics/application
Métricas básicas :8080/metrics/base
Métricas de provedores :8080/metrics/vendor
Todas as métricas : 8080/métrica
Cliente MicroProfile Rest
Os microservizos adoitan ofrecer puntos finais RESTful que requiren as API do cliente correspondentes para traballar. Para usar puntos finais RESTful, os desenvolvedores de Spring normalmente usan RestTemplate. Quarkus ofrece API MicroProfile Rest Client para resolver este problema, cuxos exemplos de uso aparecen na Táboa 8.
В o uso de puntos finais RESTful realízase mediante o MicroProfile Rest Client. Podes atopar máis información e exemplos sobre este tema no manual de Quarkus .
Táboa 8. Exemplos de uso das API do cliente MicroProfile Rest.
Características do cliente MicroProfile Rest
Descrición
Exemplos
@RegisterRestClient
Rexistra unha interface Java escrita como cliente REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Marca a implementación dunha instancia dunha interface de cliente REST escrita
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocación
Chama a un punto final REST
System.out.println(
restClient.getSalutation());
mp-rest/url
Especifica o punto final REST
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Resultados de
Neste blog, dirixido principalmente aos desenvolvedores de Spring, demos unha ollada rápida a como usar as API de Spring coas API de MicroProfile en Quarkus para desenvolver microservizos Java e, a continuación, compilalos en código binario nativo que aforra centos de megabytes de RAM e lánzaos en cuestión de milisegundos.
Como xa entendeu, pódese atopar máis información sobre o soporte para as API Spring e MicroProfile, así como moita outra información útil en .
Fonte: www.habr.com