Microservicios usando spring boot + Maven + H2 db
- Carlos
- 24 feb 2019
- 5 Min. de lectura
Actualizado: 8 mar 2019
En este tutorial vamos a ver paso a paso como desarrollar un micro-servicio usando spring boot.
Para nuestro entorno de desarrollo, usaremos netbeans como IDE, Maven y Java 8.
En el post se enseña lo básico y se explica con mayor detalle en nuestro canal de youtube donde se encuentra explicado en dos partes el paso a paso, desde el diseño y la parte teórica hasta la codificación del mismo y las respectivas pruebas. Además podrán encontrar los enlaces al código en github.
Primera parte del tutorial: https://youtu.be/sWiqF3cZbj8
segunda parte del tutorial: https://youtu.be/RNYhBikxfkc
Arquitectura de la solución y beneficios de usar spring boot.
A la izquierda de la imagen, se ha dividido en 3 partes el proceso de desarrollo de software para entender mejor en que punto nos aporta valor el framework de spring boot.
Configuración
Desarrollo
Despliegue.
Spring boot nos facilita la primera y la tercera etapa del desarrollo de software con el objetivo que los desarrolladores pueda centrarse en la codificación pura y dura sin requerir demasiadas configuraciones previas en ficheros .xml en la etapa de inicio y de despliegue.
A la derecha hemos diseñado una arquitectura típica de 3 capas, Vista, lógica de negocio y capa de acceso a datos, además hemos definido un par de objetos que representará el modelo de datos a trasmitir entre las diferentes capas con el fin de mantener el bajo acoplamiento, lo cual se indica mas adelante.
1- Crear el proyecto usando spring initializr
Para ello ingresamos a la herramienta que nos ofrece spring aquí, e indicamos los parámetros requeridos como son: grupoid y el nombre del proyecto en el apartado artifact, además podremos incluir las librerías que de antemano sabemos vamos a utilizar, si aun no lo tenemos claro podremos realizarlo más adelante; en nuestro caso las agregamos en el fichero pom como se indica en el segundo punto.
Una vez definido los parámetros indicados se debe hacer click en el botón generate project y se nos descargará el proyecto en formato zip, el cual debemos importar como proyecto en nuestro IDE favorito, en este caso en netbeans.
2- Construir el servicio.
Una vez hemos importado el proyecto en el IDE, podemos ver (en la siguiente imagen) que se nos ha creado un proyecto con una clase que tiene definido un método Main, el cual llama al método run de la clase SpringAplication con nuestra clase principal que esta anotada con @SpringBootApplication, lo cual le indica al framework de spring todo lo necesario para que trate nuestro proyecto con la configuración automática de spring boot.
2.1 Agregar las siguientes dependencias en el fichero pom.xml.
Agrega las siguientes dependencias a fichero pom.xml del proyecto recién creado y posteriormente en dependencias haces click derecho y seleccionas la opción descargar dependencias declaradas.
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>net.sf.dozer</groupId>
<artifactId>dozer</artifactId>
<version>5.5.1</version>
</dependency>
</dependencies>
2.2 Crear clase Entity que representará el objeto en base de datos.
Dado que para el ejemplo usaremos H2 que es la base de datos en memoria que nos permitirá probar el microservicio sin requerir instalar un motor de base de datos como postgres MySQL u otro, vamso a crear una entidad sencilla con datos básicos de un cotacto que nos representará una tabla en dicha base de datos.
@Entity
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid", strategy = "uuid")
private String id;
private String name;
private String phone;
private String addres;
public String getId() {
return id;
}
getter and setter methods ...
}
2.3 Crear la clase de accesos a datos.
El framework de Spring nos ofrece en su implementación de JPA una opción bastante sencilla mediante la interface JpaRepository para crear los principales métodos de acceso a datos (CRUD) con los cuales podremos crear, eliminar modificar y consultar en la base de datos delegando estas tareas en el propio framework y reduciendo el tiempo de desarrollo.
Para ello basta con crear una interface propia en nuestro proyecto, que extienda de dicha interface y se le indique el tipo de Objeto que va a manejar junto con su id, en este caso le indicaremos que el objeto será la Entidad creada en el punto anterior y su respectivo id.
public interface DemoRepository extends JpaRepository<Person, String>{
}
2.4 Crear la capa de negocio.
Para el caso practico la capa de negocio será bastante sencilla y consistirá únicamente de una clase que tiene una referencia a la interface creada previamente, con un método para consultar todas las entidades Persona que existan en la base de datos y otro para guardar dichas entidades; este par de métodos los serviremos mediante el servicio que estamos construyendo (es decir finalmente será el usuario de este servicio quien los invoque).
@Service
public class DemosServices {
@Autowired
DemoRepository demoRepository;
public void save(Person person){
demoRepository.save(person);
}
public List<Person> getAll(){
return demoRepository.findAll();
}
}
2.5 Crear un objeto dto para la capa de la vista
Esto nos permitirá mantener el bajo acoplamiento, dado que podremos independizar completamente la capa de la vista de las otras capa de la aplicación y además nos favorecerá la escalabilidad en el futuro, el objeto debe ser identico al Entity pero sin indicar la anotación @Entity.
public class PersonRequest {
private String id;
private String name;
private String phone;
private String addres;
public PersonRequest() {
}
public PersonRequest(String id, String name, String phone, String addres) {
this.id = id;
this.name = name;
this.phone = phone;
this.addres = addres;
}
All getters and setters methods ...
}
2.6 Crear un mapper para mapear del dto a nuestro entity y viceversa.
Debido a que hemos optado por mantener la independencia entre las capas debemos crear esta clase auxiliar para usarla en nuestra API que vamos a crear en el siguiente punto y de esta manera tendremos todo automatizado, para evitar la conversión de objetos de manera manual.
@Configuration
public class DozerMapping {
@Bean
public Mapper mapperDozer(){
return new DozerBeanMapper();
}
}
2.7 Crear la API (clase que representará el servicio).
Esta será la clase que vamos a exponer con los diferentes métodos http para nuestro servicio, básicamente se corresponde con los dos métodos definidos en 2.4 para listar y guardar objetos.
@RestController
public class PersonApi {
@Autowired
DemosServices demosServices;
@Autowired
Mapper mapper;
@RequestMapping(value = "/person", method = RequestMethod.GET)
public List<PersonRequest> getPerson(){
List<Person> all = demosServices.getAll();
List<PersonRequest> list = new LinkedList<>();
for(Person dto:all){
PersonRequest map = mapper.map(dto, PersonRequest.class);
list.add(map);
}
return list;
}
@RequestMapping(value = "/person", method= RequestMethod.POST)
public void savePerson(@RequestBody PersonRequest personRequest){
Person map = mapper.map(personRequest, Person.class);
demosServices.save(map);
}
}
3- Probar y pasar a producción el servicio
En este punto tendremos un servicio 100% funcional y al momento de compilarlo el resultado será un fichero .jar el cual podremos ejecutar desde nuestro IDE o desde una linea de comandos (Java -jar tufichero.jar).
Este fichero .jar estará listo para desplegarse en un entorno productivo.
Dado que el fichero .jar tendrá un servidor web auto-contenido aportado por el framework de spring boot, ya tendremos nuestro servicio disponible para acceder mediante http o JMX.
En este caso vamos a probarlo usando un cliente REST como "Restlet Client - REST API Testing" por ejemplo que puede añadirse al navegador chrome.
Primero usaremos el método POST para crear nuestro primer objeto con la siguiente estructura.
{"id":"96847","name":"pedro","phone":"8957","addres":"calle Alcala"}
Seguidamente ejecutaremos un método GET para consultar los objetos creados.
Comments