Micronaut es una nueva generación de marco de microservicio de pila completa basado en JVM para crear aplicaciones de microservicio modulares y fáciles de probar. Este artículo presenta brevemente el uso de micronauta para crear aplicaciones de microservicio a través de dos ejemplos simples.
1. Dirigir un centro de registro de cónsules
Descarga consul
Dado que la descarga desde el sitio web oficial es demasiado lenta, puede encontrar otros recursos, como este: https://download.csdn.net/download/m0_46455711/13184176
puesta en marcha
Descomprima el archivo descargado, solo hay un archivo consul.exe, simplemente ejecútelo directamente desde la línea de comando:
.\consul.exe agent -dev -ui
Abra el navegador y visite: http: // localhost: 8500 /. Si encuentra que puede visitar, significa que el cónsul del centro de registro está listo:
Dos, instale micronauta
- Primero, descargue el marco de micronauta, puede descargarlo del sitio web oficial, pero es más lento, puede descargarlo aquí: https://download.csdn.net/download/m0_46455711/13184282
- Descomprima el archivo descargado y agregue su directorio bin a la variable de entorno Path
En tercer lugar, cree una aplicación de microservicio con el cónsul como registro.
Comando de construcción del proyecto
Ejecute los siguientes comandos en el directorio donde se coloca el proyecto para construir un proyecto de servicio:
mn create-app my-app1 --lang groovy --features hibernate-gorm,config-consul,discovery-consul
Aquí my-app1 es el nombre del proyecto, groovy está designado como el lenguaje de desarrollo principal, hibernate-gorm está habilitado como el marco de datos, config-consul es el centro de configuración y descubrimiento de registro del servicio discovery-consul
Proyecto construido
Después de ejecutar el comando, se generará un proyecto con la siguiente estructura de directorios en el directorio actual:
abra build.gradle y podemos ver que se han agregado las dependencias relacionadas, por supuesto también podemos agregar otras dependencias aquí:
abra el archivo bootstrap.yml, podemos ver que la dirección del registro del servicio se ha configurado como local y 8500, que es el cónsul que ejecutamos anteriormente.Por supuesto, también podemos configurar el puerto del servicio actual aquí:
application.yml es configurado con una base de datos h2 e hibernar de
forma predeterminada : predeterminado En este caso, aquí está gradle-6.7-bin.zip, pero descubrí que la descarga no se puede descargar durante mucho tiempo, por lo que puede cambiarla manualmente a local zip descargado. Por ejemplo, aquí, lo cambié a gradle-6.7-all.zip
Cuatro, escribe código
1. Cree una clase de dominio (una comprensión simple es la clase de operación de la base de datos), llamada SomeTest:
package my.app1.domain
import grails.gorm.annotation.Entity
@Entity
class SomeTest {
long id
String name
}
Cabe señalar que se requiere la anotación @Entity, indica que esta clase es una clase de dominio
2. Crea un servicio
package my.app1.service
import grails.gorm.transactions.Transactional
import my.app1.domain.SomeTest
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import javax.inject.Singleton
@Singleton
@Transactional
class HelloService {
private static Logger log = LoggerFactory.getLogger(HelloService.class)
void addSomeTest(){
SomeTest someTest=new SomeTest()
someTest.id=0
someTest.name="hello"
if(!someTest.save(flush:true)){
log.error("保存数据到数据库出错：",someTest.getErrors())
}
}
List<SomeTest> findAllSomeTest(){
return SomeTest.findAll()
}
}
La anotación @Singleton aquí indica el monómero, y la anotación @Transactional indica que la clase de dominio se puede usar aquí
3. Crea un controlador
package my.app1.controller
import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import my.app1.domain.SomeTest
import my.app1.service.HelloService
import javax.inject.Inject
@Controller("/hello")
class HelloController {
@Inject
HelloService helloService
@Get(uri="/add", produces="text/plain")
String add() {
helloService.addSomeTest()
return "ok"
}
@Get(uri="/all", produces= MediaType.APPLICATION_JSON)
List<SomeTest> all() {
return helloService.findAllSomeTest()
}
}
No hay nada que decir sobre esto, lo único que puedo decir es que la anotación @Inject se usa aquí para inyectar el servicio que creamos anteriormente.
Hasta ahora, hemos creado un microservicio con capacidades de operación de base de datos. Ejecute el método principal en la Aplicación para iniciar el microservicio. Una vez que el inicio sea exitoso, use el navegador para acceder a la interfaz correspondiente y descubra que no hay problema, y también está registrado en el servicio de cónsul.
5. Escribe otro microservicio y accede a él a través del registro.
Un requisito clave del marco de microservicios es el registro y descubrimiento de servicios y la invocación entre servicios. A través de la descripción anterior, sabemos que micronaut ha integrado el cliente de cónsul, pudiendo registrarse automáticamente en el registro del servicio después de que se inicia el servicio mediante una simple configuración. Por supuesto, micronaut también proporciona un buen soporte para el descubrimiento de servicios y la invocación de servicios.
1. Cree un nuevo microservicio
mn create-app my-app2 --lang groovy --features hibernate-gorm,config-consul,discovery-consul
2. Configure el puerto de servicio
micronaut:
server:
port: 8082
3. Crea un nuevo controlador
package my.app2
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import org.slf4j.Logger
import org.slf4j.LoggerFactory
@Controller("/hello")
class HelloController {
private static Logger log = LoggerFactory.getLogger(HelloController.class)
@Get(uri="/", produces="text/plain")
String index() {
log.info("im hello two")
"im hello two"
}
}
4. Agregue un servicio para llamar al cliente en el microservicio my-app1
package my.app1.client
import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Get
import io.micronaut.http.client.annotation.Client
import io.micronaut.retry.annotation.Retryable
@Client("myApp2")
@Retryable
interface HelloClient {
@Get(value = "/hello", processes = MediaType.TEXT_PLAIN)
String hello()
}
La anotación @Client identifica esta interfaz como una interfaz de llamada de servicio, y myApp2 es el nombre del servicio (después de que el comando se usa para construir my-app2, el nombre del servicio creado es myApp2, que se puede ver y modificar en el archivo de configuración bootstrap. yml), y también vale la pena señalar que el nombre del servicio aquí también se puede reemplazar con la dirección http específica y el puerto del servicio llamado.
5. Agregue un respaldo al microservicio my-app1 para que la interfaz llamada devuelva un valor predeterminado cuando el servicio no esté disponible.
package my.app1.client;
import io.micronaut.retry.annotation.Fallback;
import io.micronaut.retry.annotation.Recoverable;
@Fallback
@Recoverable
public class HelloFallback implements HelloClient {
@Override
public String hello() {
return "i am hello fallback";
}
}
Lo que debe tenerse en cuenta aquí es que debe ser un archivo java en lugar de un archivo maravilloso. No sé la razón específica. Estoy muy deprimido.
6. Utilice el servicio para llamar al cliente en el microservicio my-app1
Use @Inject para inyectar al cliente, llame a la interfaz de servicio como un método normal
7. Inicie el servicio my-app2 recién creado y reinicie el servicio my-app1.
Acceso al navegador: http: // localhost: 8081 / hello / add, puede ver el retorno: ok, soy hola dos
para resumir
No hay nada que resumir, simplemente pegue la dirección de descarga del ejemplo
https://gitee.com/luoye_lj/micronaut_example