Categoría: JAVA

  • Introducción al Mocking en Spring: Guía para Potenciar tus Pruebas Unitarias

    Introducción al Mocking en Spring: Guía para Potenciar tus Pruebas Unitarias

    En Spring, el término Mocking se refiere a la técnica utilizada en pruebas unitarias para simular el comportamiento de objetos reales. Estos objetos simulados, también llamados mocks, se utilizan en lugar de los objetos reales con los que interactúa la unidad de código que se está probando.

    El uso de mocks tiene varias ventajas:

    • Aislamiento: Permite aislar la unidad de código que se está probando de sus dependencias externas, facilitando la escritura de pruebas unitarias más rápidas y enfocadas.
    • Control: Se puede definir el comportamiento específico del mock para cada interacción que tenga, lo que permite controlar el flujo de la prueba y verificar las expectativas.
    • Fiabilidad: Al eliminar la dependencia de objetos reales, se evitan las interferencias externas que podrían afectar el resultado de la prueba.

    Spring no proporciona un framework propio para mocking, pero se integra perfectamente con frameworks populares como Mockito, implementándolos directamente o a través de su modulo de Spring-Test.

    Complejidades de Spring Test

    Spring Test ofrece una gran cantidad de funcionalidades para la escritura de pruebas en aplicaciones Spring, pero también presenta algunas complejidades:

    1. Curva de aprendizaje: Spring Test tiene una API amplia y puede ser difícil de aprender para principiantes. La configuración del contexto de Spring, la inyección de dependencias y la gestión de transacciones pueden ser tareas complejas.

    2. Verbosidad: El código de las pruebas con Spring Test puede ser verboso, especialmente al configurar mocks y stubs(fragmento de código que responde a una funcionalidad de manera temporal). Esto puede dificultar la lectura y el mantenimiento de las pruebas.

    3. Rigidez: Spring Test está diseñado para trabajar con la arquitectura de Spring, lo que puede limitar su flexibilidad para probar diferentes tipos de aplicaciones.

    4. Dependencia de Spring: Las pruebas que usan Spring Test dependen del framework de Spring, lo que puede dificultar la ejecución de las pruebas en entornos que no son de Spring.

    Mockito: Framework de Mocking para Java

    Mockito es un framework de código abierto para crear pruebas unitarias en Java. Se utiliza para crear mocks que vimos anteriormente, replicando el comportamiento de objetos reales. Los mocks se pueden usar para:

    • Simular el comportamiento de dependencias en pruebas unitarias, evitando la necesidad de interactuar con objetos reales.
    • Verificar que la unidad de código interactúa con las dependencias de la forma esperada.
    • Probar diferentes escenarios sin necesidad de configurar un entorno real.

    Características principales de Mockito:

    • Fácil de usar: La sintaxis de Mockito es intuitiva y fácil de aprender.
    • Potente: Permite crear mocks complejos con un alto grado de control sobre su comportamiento.
    • Flexible: Se puede usar con diferentes frameworks de pruebas unitarias como JUnit, TestNG y Spock.
    • Extensible: Se pueden crear matchers personalizados para verificar las interacciones con los mocks.
    • Ampliamente utilizado: Es uno de los frameworks de mocking más populares para Java.

    Ejemplos de uso de Mockito:

    • Simular una base de datos: Se puede crear un mock de una base de datos para probar una clase que interactúa con ella.
    • Simular un servicio web: Se puede crear un mock de un servicio web para probar una clase que consume sus APIs.
    • Simular un objeto de terceros: Se puede crear un mock de un objeto de terceros para probar una clase que depende de él.

    Te invitamos a suscribirte a nuestro blog para recibir contenido exclusivo sobre pruebas en Spring y Mockito, además de otros temas de tecnología que te apasionarán.

    ¡Deja tu comentario!

    Comparte tus experiencias, dudas y opiniones sobre estas herramientas. ¡Comencemos una conversación sobre las mejores prácticas para las pruebas en Spring!


    ¡Conviértete en un experto tecnológico! 🚀 Suscríbete a nuestro newsletter y recibe las últimas noticias, análisis y tendencias directamente en tu bandeja de entrada. No te pierdas las actualizaciones que harán que tu experiencia tecnológica sea aún más emocionante. ¡Únete a nuestra comunidad hoy! 📧✨

  • Explorando las Características Estelares de Spring Framework para Crear Aplicaciones Java Robustas y Escalables

    Explorando las Características Estelares de Spring Framework para Crear Aplicaciones Java Robustas y Escalables

    ¿Cansado de la complejidad del desarrollo de aplicaciones Java? Spring Framework te ofrece una solución. Este framework de código abierto te permite crear aplicaciones empresariales robustas y escalables con mayor facilidad y rapidez.

    ¿Qué es Spring Framework?

    Spring Framework es un marco de trabajo para el desarrollo de aplicaciones Java que proporciona un conjunto integral de características y servicios para simplificar el desarrollo de software empresarial. Sus principales usos están en:

    • Desarrollo de aplicaciones web: Spring Boot es una herramienta ideal para el desarrollo de aplicaciones web modernas y escalables. Ofrece una configuración automática de servidores web como Tomcat, Jetty o Undertow, lo que facilita el inicio del desarrollo.
    • Microservicios: Spring Boot es una excelente opción para la creación de microservicios, gracias a su enfoque modular y a su capacidad para crear aplicaciones independientes.
    • Aplicaciones en la nube: Spring Boot se integra fácilmente con plataformas en la nube como Amazon Web Services (AWS), Microsoft Azure y Google Cloud Platform (GCP).
    • Internet de las cosas (IoT): Spring Boot puede usarse para desarrollar aplicaciones IoT que se ejecutan en dispositivos con recursos limitados.
    • Procesamiento de datos: Spring Boot ofrece una serie de características que facilitan el desarrollo de aplicaciones de procesamiento de datos, como la integración con bases de datos y frameworks de big data.

    Principales características de Spring Framework

    Algunas de las principales características de Spring Framework son:

    • Inversión de control (IoC): Spring utiliza el principio de Inversión de Control para manejar la creación y gestión de objetos en una aplicación. En lugar de que los objetos creen y gestionen sus dependencias, Spring los gestiona, lo que facilita la configuración y el mantenimiento.
    • Contenedor de Spring (Spring Container): Proporciona un contenedor liviano y flexible que gestiona la creación, configuración y destrucción de objetos (beans).
    • Inyección de dependencias (DI): Spring facilita la inyección de dependencias, lo que permite que los objetos obtengan sus dependencias de una fuente externa (generalmente un contenedor de Spring) en lugar de crearlas internamente.
    • Aspect-Oriented Programming (AOP): Permite separar las preocupaciones transversales del código de negocio principal. Esto facilita la modularidad y el mantenimiento del código.
      Imagina que estás construyendo una aplicación y te das cuenta de que hay ciertas preocupaciones o tareas que se repiten en diferentes partes del código, como el manejo de transacciones, el registro de eventos o la seguridad. A veces, estas preocupaciones están entrelazadas con la lógica principal de tu programa, lo que puede hacer que el código sea más complejo y difícil de mantener. Aquí es donde entra en juego AOP que separa encapsulando en un “aspecto”.
    • Manejo de transacciones: Spring facilita la gestión de transacciones en aplicaciones Java mediante el soporte para transacciones declarativas y programáticas.
    • Desarrollo basado en POJO: Spring permite usar clases simples (POJO) para el desarrollo de aplicaciones, lo que facilita el código y lo hace más mantenible.

    Algunas de estas características ya vimos como implementarlas y usarlas en un anterior post.

    ¿Cómo lo hace?

    Spring está compuesto por módulos independientes que se pueden usar según las necesidades del proyecto. Esto permite un desarrollo más flexible y adaptable. Veamos alguno de los módulos mas usados:

    • Spring Core: Contiene funcionalidades básicas como la inyección de dependencias, contenedores de IoC y anotaciones.

    • Spring Web Flow: Proporciona un marco de trabajo MVC (Modelo-Vista-Controlador) para el desarrollo de aplicaciones web. Facilita la creación de aplicaciones web escalables y bien estructuradas.

    • Spring Data: Simplifica la interacción con bases de datos al proporcionar un conjunto de abstracciones y facilitar el acceso a datos mediante tecnologías como JDBC(Java Database Connectivity) y JPA (Java Persistence API).

    • Spring Security: Ofrece características de seguridad para proteger aplicaciones, incluyendo autenticación, autorización y protección contra ataques comunes.

    • Spring Boot: Extiende las capacidades de Spring al proporcionar un marco de trabajo de desarrollo de aplicaciones basado en opiniones que facilita la creación rápida y el despliegue de aplicaciones Spring. Es decir que ofrece configuraciones comunes para arrancar rápidamente un proyecto.

    • Spring Batch: Proporciona funcionalidades para el procesamiento por lotes, lo que facilita la implementación de tareas de procesamiento de datos en grandes volúmenes.

    • Spring Integration: Facilita la integración con diferentes sistemas y tecnologías externas implementando patrones de integración empresarial.

    • Spring Cloud: Facilita el desarrollo de aplicaciones en la nube con Spring Boot por medio de herramientas rápidas para crear sitios distribuidos.

    • Spring Kafka: Permite la integración con Apache Kafka para el procesamiento de flujos de datos.

    Spring Framework ofrece una amplia gama de módulos para diferentes necesidades, así que si quieres profundizar mas en ellos puedes ir a la documentación oficial desde aquí, o si lo prefieres deja tu comentarios y dudas para ampliarlos en futuros post.

    También te recomiendo ver anotaciones y configuración en Spring. ¡Hasta la próxima!


    ¡Conviértete en un experto tecnológico! 🚀 Suscríbete a nuestro newsletter y recibe las últimas noticias, análisis y tendencias directamente en tu bandeja de entrada. No te pierdas las actualizaciones que harán que tu experiencia tecnológica sea aún más emocionante. ¡Únete a nuestra comunidad hoy! 📧✨

  • Paso a paso para montar tu entorno de desarrollo de Java

    Paso a paso para montar tu entorno de desarrollo de Java

    Descarga Java JRE
    Descarga Java JRE (Java Runtime Environment) que es el conjunto de software desarrollado por Oracle Corporation que proporciona la máquina virtual de Java (Java Virtual Machine, JVM) y otras bibliotecas y componentes necesarios para ejecutar aplicaciones Java. La máquina virtual de Java permite que las aplicaciones escritas en el lenguaje de programación Java se ejecuten en cualquier dispositivo o sistema que tenga instalado el Java JRE, independientemente de las diferencias de hardware o sistema operativo. sitio oficial.
    Instala Java JRE
    Ejecuta el archivo de instalación descargado y sigue las instrucciones del asistente de instalación.
    Verificar JRE
    Abre la línea de comandos (cmd) y escribe java -version. Deberías ver información sobre la versión de Java instalada.
    Descarga Java JDK
    Descarga el JDK desde el sitio oficial. Tienes dos opciones, el instalador y el archivo zip, te recomiendo usar el instalador ya que te lleva por un paso a paso.
    Variables de entorno
    Si instalaste por medio del asistente asegúrate de que se crearon las variables del sistema, en caso de no tenerlas o que hayas hecho la descompresión del zip agrega las variables del sistema. La ruta debe ser similar a esta: C:\Program Files\Java\jdk1.x.x\bin
    Verificar
    Verifica la instalación con javac -version.
    Entorno de desarollo
    Configurar un IDE. Netbeans, Eclipse o especialmente recomendado IntelliJ IDEA.
    Desarrolla
    Crear tu Primera Aplicación Java.
    Descarga Java JRE
    Puedes instalar Java a través de la Terminal o mediante el instalador gráfico.
    Instala Java JRE
    Ejecuta el archivo de instalación descargado y sigue las instrucciones del asistente de instalación. Desde la Terminal, puedes usar el siguiente comando: /usr/libexec/java_home. Este comando te dará la ubicación del directorio de Java. Puedes agregar esto al archivo .zshrc o .bash_profile para configurar la variable de entorno.
    Verificar JRE
    Abre la Terminal y escribe java -version. Deberías ver información sobre la versión de Java instalada.
    Descarga Java JDK
    Descarga el JDK desde el sitio oficial. Tienes dos opciones, el instalador(DMG) y el archivo zip, te recomiendo usar el instalador ya que te lleva por un paso a paso.
    Variables de entorno
    Si instalaste por medio del asistente asegúrate de que se crearon las variables del sistema, en caso de no tenerlas o que hayas hecho la descompresión del zip agrega las variables del sistema de la siguiente manera:
    export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.x.x
    export PATH=$PATH:$JAVA_HOME/bin
    Guarda el archivo de perfil que hayas modificado para aplicar los cambios.
    Verificar
    Verifica la instalación con javac -version.
    Entorno de desarollo
    Configurar un IDE. Netbeans, Eclipse o especialmente recomendado IntelliJ IDEA.
    Desarrolla
    Crear tu Primera Aplicación Java.
    Descarga Java JRE
    En muchas distribuciones de Linux, puedes instalar Java a través del gestor de paquetes. Por ejemplo, en Ubuntu, puedes usar:
    sudo apt update
    sudo apt install default-jre
    Verificar JRE
    Abre la Terminal y escribe java -version. Deberías ver información sobre la versión de Java instalada.
    Descarga Java JDK
    Descarga el archivo tar.gz y sigue las instrucciones específicas de tu distribución para la instalación del JDK desde el sitio oficial.
    Variables de entorno
    Agrega las variables del sistema de la siguiente manera:
    export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.x.x
    export PATH=$PATH:$JAVA_HOME/bin
    Guarda el archivo de perfil que hayas modificado para aplicar los cambios.
    Verificar
    Verifica la instalación con javac -version.
    Entorno de desarollo
    Configurar un IDE. Netbeans, Eclipse o especialmente recomendado IntelliJ IDEA.
    Desarrolla
    Crear tu Primera Aplicación Java.

    ¡Conviértete en un experto tecnológico! 🚀 Suscríbete a nuestro newsletter y recibe las últimas noticias, análisis y tendencias directamente en tu bandeja de entrada. No te pierdas las actualizaciones que harán que tu experiencia tecnológica sea aún más emocionante. ¡Únete a nuestra comunidad hoy! 📧✨

  • Java: El lenguaje de programación versátil y poderoso

    Java: El lenguaje de programación versátil y poderoso

    Java es un lenguaje de programación de propósito general, orientado a objetos y robusto que ha dominado la industria del software durante décadas. Su versatilidad lo hace ideal para desarrollar una amplia gama de aplicaciones, desde aplicaciones web y móviles hasta grandes sistemas empresariales. En este post, exploraremos las características clave de Java, sus ventajas y desventajas, qué necesitas para empezar, algunos proyectos para iniciarte y enlaces para ampliar tu conocimiento.

    Características

    • Orientado a objetos: Java organiza el código en torno a objetos, lo que facilita la reutilización del código y la creación de aplicaciones escalables.
    • Multiplataforma: Java se ejecuta en la Máquina Virtual de Java (JVM), lo que significa que el código Java puede ejecutarse en cualquier sistema operativo que tenga una JVM instalada.
    • Robusto: Java está diseñado para ser un lenguaje de programación seguro y confiable, lo que lo hace ideal para aplicaciones críticas.
    • Amplia biblioteca de clases: Java tiene una amplia biblioteca de clases estándar que proporciona funcionalidad para una variedad de tareas comunes.

    Ventajas

    • Versátil: Java se puede usar para desarrollar una amplia gama de aplicaciones.
    • Multiplataforma: El código Java se puede ejecutar en cualquier sistema operativo.
    • Robusto: Java es un lenguaje de programación seguro y confiable.
    • Gran comunidad: Java tiene una gran comunidad de desarrolladores que pueden ayudarte a encontrar soluciones a tus problemas.

    Desventajas

    • Curva de aprendizaje: Java puede ser un lenguaje de programación difícil de aprender para principiantes.
    • Consumo de memoria: Las aplicaciones Java pueden consumir más memoria que las aplicaciones escritas en otros lenguajes de programación.
    • Velocidad: Java puede ser más lento que otros lenguajes de programación en algunas situaciones.

    ¿Qué necesitas para empezar?

    • Un ordenador con un sistema operativo compatible: Windows, macOS, Linux.
    • Java Runtime Environment (JRE): o Entorno de ejecución de Java, es un software esencial para ejecutar aplicaciones Java en cualquier sistema operativo. Funciona como un puente entre el programa Java y el sistema operativo, proporcionando los recursos necesarios para que la aplicación funcione correctamente.
    • Un editor de código o un IDE (Entorno de desarrollo integrado): NetBeans, IntelliJ IDEA, Eclipse. Yo especialmente uso IntelliJ IDEA así que me veras con ese en las practicas.
    • El JDK (Java Development Kit): Es un conjunto de herramientas de software que te permite crear aplicaciones con Java. Se considera la piedra angular del desarrollo Java, ya que proporciona todo lo que necesitas para escribir, compilar y ejecutar código Java. Ampliaremos mas sobre el JDK a continuación.

    Componentes esenciales del JDK

    • Compilador: Convierte el código fuente Java (.java) en bytecode (.class), que puede ser interpretado por la Máquina Virtual de Java (JVM).
    • Intérprete: Ejecuta el bytecode generado por el compilador.
    • Bibliotecas: Ofrecen una amplia gama de funcionalidades predefinidas que puedes utilizar en tus aplicaciones.
    • Herramientas: Ayudan a depurar código, documentar tu proyecto, generar código y realizar otras tareas de desarrollo.
    Java toolbox

    Proyectos para iniciarte

    • Hola Mundo: Lo primero es lo primero. Imprime el mensaje “Hola Mundo” en la pantalla.
    • Calculadora: Crea una calculadora simple que pueda realizar operaciones básicas.
    • Juego: Crea un juego simple, como un juego de adivinanzas o un juego de memoria.

     

    Una vez tengas dominadas las estructuras de control para Java y entiendas como trabajarlos saltaremos al Framework de Spring. También te dejo es link que es un tutorial oficial de Oracle para Java. Practica mucho y hasta la próxima, deja tus dudas y comentarios.


    ¡Conviértete en un experto tecnológico! 🚀 Suscríbete a nuestro newsletter y recibe las últimas noticias, análisis y tendencias directamente en tu bandeja de entrada. No te pierdas las actualizaciones que harán que tu experiencia tecnológica sea aún más emocionante. ¡Únete a nuestra comunidad hoy! 📧✨

  • Spring Boot – Configuración

    Spring Boot – Configuración

    Vimos anteriormente que se puede hacer la inyección de dependencias por medio de archivos xml y usando anotaciones; sin embargo también podemos usar clases de configuración para instanciar objetos de manera fácil y limpia.

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    @Configuration
    public class AppConfig {
         
        @Bean("student")
        public Student getStudent(Service service) {
            return new StudentImpl(service);
        }
         
        @Bean("service")
        public Service getService() {
            return new ServiceImpl();
        }
    }

    La ventaja de este método es que permite liberar a las clases de negocio de anotaciones, dejándolas limpias.

    La clave es marcar la clase con el decorador @Configuration, es cual es procesado por el Spring IoC, que en este caso crea las instancias marcadas con @Bean.

    Veamos un ejemplo muy básico:

    1. Creamos una interfaz con un método de prueba:
      public interface Service {
          String hello();
      }
    2. Creamos la implementación del servicio:
      public class ServiceImpl implements Service {
          @Override
          public String hello() {
              return "Hola";
          }
      }
    3. Creamos el archivo de configuración:
      @Configuration
      public class Config {
          @Bean("service")
          public Service getService() {
              Service myService = new ServiceImpl();
              System.out.println(myService.hello());
              return myService;
          }
      }

      Lo que hacemos es instanciar la implementación e imprimir en consola el String que viene del método hello, lo que resulta que al ejecutar la aplicación veamos un “hola” en consola.

        .   ____          _            __ _ _
       /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
      ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
       \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
        '  |____| .__|_| |_|_| |_\__, | / / / /
       =========|_|==============|___/=/_/_/_/
       :: Spring Boot ::                (v2.7.0)
      
      Hola

    Al ser una clase Java obtenemos las ventajas propias del lenguaje, como asegurarnos del tipado correcto, comprobación en tiempo de compilación y algo mas amigable para la lectura.

    También si se desea, podemos usar las anotaciones en conjunto con con las clases de configuración.

  • Spring Boot – Anotaciones

    Spring Boot – Anotaciones

    Segunda parte del curso Spring Boot

    En el anterior post hablamos de los conceptos básicos, y este es uno de los principales, pero merece un espacio propio.

    Tocamos temas sobre inyección de dependencias y beans, sin embargo no hablamos del ciclo de vida de estos componentes, por lo que vamos a empezar por ahí.

    Teníamos nuestro archivo XML para inicializar los beans y dijimos que podemos inicializar varios; en muchos casos estos beans dependen de otros, es decir que debemos inyectar las dependencias y comportamiento. Esto lo logramos usando la interfaz de BeanPostProcessor que nos permite crear objetos y asignar comportamientos antes y después de crear los beans con los metodospostProcessBeforeInitialization y postProcessAfterInitialization respectivamente. Lo que hace Spring es justamente en los anteriores métodos por medio de Reflexion instanciar los objetos necesario y asignar el comportamiento deseado. A partir de Spring 3.5 se implemento la autodetección de beans, es decir que ya no es necesario usar un XML para inyectar cada uno de nuestros beans. Esto se logra a través de las anotaciones.

    ¿Qué es una anotación?

    Una anotación es un metadato que se incrusta en el código, se caracterizan por iniciar con el carácter @, este no cambia el comportamiento del código pero si puede indicarle al compilador acciones especificas de lectura o ejecución, por ejemplo, Java por defecto tiene varias anotaciones, una de las mas conocidas es @Override que se utiliza para asegurar que un método heredado se sobrescribe. Así como ésta hay muchas mas y además se pueden crear anotaciones propias.

    Spring se vale de anotaciones para indicarte la la interfaz BeanPostProcessor como instanciar los beans. En el siguiente ejemplo busca la anotación @MyAnnotation:

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Method[] methods = bean.getClass().getDeclareMethods();
        for (Method get Bean: methods) {
            if (method.getAnnotation(MyAnnotation.class) != null) {
                Class[] args = method.getParameterTypes();
                try {
                    Object obj = context.getBean(args[0]);
                    method.invoke(bean, obj);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    Spring provee unas anotaciones por defecto, vamos a ver las principales.

    Anotaciones y componentes

    @Component

    Esta anotación le indica a Spring Boot que debe tratar la clase con el decorador como un bean, es decir que el propio motor se encargará de hacer la inyección.

    import org.springframework.stereotype.Component;
    
    @Component
    public class MyClass {

    @Repository, @Service y @Controller son especializaciones de @Component.

    @Repository

    Se utiliza para la capa de persistencia, en otras palabras, clases que interactúan con la base de datos. Tiene la particularidad de que tiene un control de errores mas especifico para interactuar con la sintaxis de base de datos, causando un mejor manejo de estos objetos.

    @Service

    Este se utiliza en la capa de servicio, es decir que se espera que sea lógica de negocio.

    @Controller

    Esta anotación nos enlaza con la capa de presentación, allí solemos colocar las urls que se exponen vía web.

    @Controller
    @RequestMapping("students")
    public class StudentController {
    
        @GetMapping("/{id}", produces = "application/json")
        public @ResponseBody Student getStudent(@PathVariable int id) {
            return studentService.getStudentById(id);
        }
    }

    Esta anotación se suele usar mucho en los servicios web junto con la anotación @ResponseBody que permite mapear nuestra respuesta a un objeto JSON.

    Ya que este tipo de comportamiento es el mas común, desde la versión 4.0 de Spring se creo una nueva anotación que los incluye a ambos:

    @RestController

    @RestController
    @RequestMapping("students")
    public class StudentController {
    
        @GetMapping("/{id}", produces = "application/json")
        public Student getStudent(@PathVariable int id) {
            return studentService.getStudentById(id);
        }
    }

    @Autowired

    Esta anotación nos sirve para indicarle que vamos a inyectar un bean dentro de otro, es decir como una propiedad o también lo podemos usar en los métodos set; esto quiere decir que podemos darle el control al framework para que cree la instancia de los componentes, esto es importante ya que solo podemos utilizar esta anotación para inicializar componentes definidos en el contexto de Spring, es decir, que tengan el decorador @Component o alguna de sus especializaciones.

    En el siguiente ejemplo se muestra la instanciación de un servicio como propiedad de otro bean(controlador):

    @Service
    public class StudentService {
    @RestController
    @RequestMapping("students")
    public class StudentController {
    
        @Autowired
        private StudentService studentService;
    
        @GetMapping("/{id}", produces = "application/json")
        public Student getStudent(@PathVariable int id) {
            return studentService.getStudentById(id);
        }
    }

    Con esta anotación nos surge un problema que vamos a ilustrar a continuación:

    @Service
    public class StudentService implements PersonService {
    @Service
    public class TeacherService implements PersonService {

    La idea es que queremos inicializar una instancia de la interfaz PersonService, en este caso hay dos posibles orígenes y @Autowired no sabría cual implementar, para solucionar esto podemos usar la anotación @Qualifier de la siguiente manera:

    @Service
    @Qualifier("student")
    public class StudentService implements PersonService {
    @Service
    @Qualifier("teacher")
    public class TeacherService implements PersonService {
    @RestController
    @RequestMapping("registration")
    public class RegistrationController {
    
        @Autowired
        @Qualifier("student")
        private PersonService personService;
    
        @GetMapping("/info/{id}", produces = "application/json")
        public Person getDataPerson(@PathVariable int id) {
            return personService.getBasicDataById(id);
        }
    }

    De esta manera podemos indicarle específicamente que tipo implementar. En el anterior ejemplo obtenemos la instancia del servicio StudentService.

    @Value

    Esta anotación nos sirve para inyectar valores en los campos de un constructor o método. En el siguiente ejemplo se obtiene un valor del archivo .properties y se le asigna a una variable. Podemos ver el @Value asignado a diferentes tipos de datos e incluso establecemos un valor por defecto.

    @Service
    @Qualifier("teacher")
    public class TeacherService implements PersonService {
    
        @Value("${university.class.code:default}")
        private String code;
    
        @Value("${university.class.subjects}")
    private String[] subjects;

    @Scope

    El Scope o ámbito indica el alcance de una instancia, en Spring tenemos por defecto la instancia de los beans como singleton (se crea una única instancia del beans, es decir que las siguientes instancias del mismo bean hacen referencia al único creado); como se mencionó por defecto funciona así, aunque si queremos especificarlo se hace de la siguiente manera:

    @Bean
    @Scope("singleton")
    public University university() {
        return new University();
    }

    En el anterior post también mencionamos que se pueden establecer los beans por medio de xml, para ese caso también podemos definir el scope.

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="personService" class="com.jhontona.service.PersonServiceImpl" scope="singleton" />
        <!--También podemos usar singleton="true" -->
    </beans>

    También podemos definir el alcance como prototype, el cual crea una instancia nueva en cada llamado.

    @Bean
    @Scope("prototype")
    public Teacher teacher() {
        return new Teacher();
    }

    Los anteriores scopes se pueden usar en cualquier aplicación de Spring, pero además tenemos scopes específicos para el ámbito web(Web Aware).

    El scope de Request se utiliza para crear una instancia nueva de bean por cada petición http, es decir que su uso mas común es con un @RestController aunque también lo podemos definir para un @Bean.

    @Bean
    @Scope(value = WebApplicationContext.SCOPE_REQUEST)
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }
    @RestController
    @RequestScope
    public class ExampleController {
    
        @GetMapping("/test")
        public String sayHello() {
                return "Hello";
        }
    
    }

    El scope de Session se utiliza para crear una instancia nueva de bean por cada sesión http

    @Bean
    @Scope(value = WebApplicationContext.SCOPE_SESSION)
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }
    @RestController
    @SessionScope
    public class ExampleController {
    
        @GetMapping("/test")
        public String sayHello() {
                return "Hello";
        }
    
    }

    El scope de Global Session se utiliza para crear una instancia nueva de bean por cada sesión http, pero este va orientado a Portlets, es decir aplicaciones que trabajan con módulos reutilizables de este tipo; las características principales de este tipo de aplicación es que dependen de un contenedor especializado en controlar estos módulos, además de que cada pagina puede estar constituida por múltiples portlets y cada una de estos tiene un request y response independiente.

    @Bean
    @Scope(value = WebApplicationContext.SCOPE_GLOBAL_SESSION)
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }

    El scope de Application se utiliza para crear una instancia nueva de bean por cada ServletContext, que por lo general en una aplicación es único(aunque podemos crear mas), comportándose como un singleton.

    @Bean
    @Scope(value = WebApplicationContext.SCOPE_APPLICATION)
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }
    @RestController
    @ApplicationScope
    public class ExampleController {
    
        @GetMapping("/test")
        public String sayHello() {
                return "Hello";
        }
    
    }

    El scope de WebSocket se utiliza para crear una instancia nueva de bean por cada websocket.

    @Bean
    @Scope(scopeName = "websocket")
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }

    Tenemos un montón de anotaciones, pero las que hemos visto son las de uso mas frecuente o nos ayudan a entender los comportamientos por defecto que toma una aplicación en Spring (si se quiere profundizar mas en estas anotaciones le recomiendo este recurso).

    Anotaciones Javax

    Con las anotaciones propias de Spring tenemos para adaptarnos a una gran variedad de situaciones, sin embargo podemos trabajar con anotaciones propias del lenguaje o provistas por paquetes externos, por ejemplo, Javax Annotation API tiene unas anotaciones interesantes que se integran con Spring.

    @PostConstruct and @PreDestroy nos sirve para llamar un método después de la instanciación del bean o antes de su destrucción, es decir que funciona como un callback.

    import javax.annotation.*;
    
    public class ExampleController {
    
        public String sayHello() {
                return "Hello";
        }
    
        @PostConstruct
        public void init(){
            System.out.println("El Bean se acaba de inicializar.");
        }
       
        @PreDestroy
        public void destroy(){
            System.out.println("El Bean se va a destruir.");
        }
    
    }

    Contamos con otras etiquetas como @Resource e @Inject que se comporta de manera muy similar al @Autowired por lo que teniendo alternativas en Spring es mas practico. Simplemente debemos saber que podemos crear o insertar anotaciones desde otros paquetes.

    Hasta aquí llega este post, espero tus preguntas, comentarios y que compartas este contenido.

  • Spring Boot – CORE

    Spring Boot – CORE

    ¿Qué es Spring Boot?

    Es un framework de código abierto para desarrollo de aplicaciones para JVM, es decir que trabajamos principalmente con Java; sin embargo, también provee soporte para lenguajes como Groovy y Kotlin.

    Este framework nos permite implementar diversas arquitecturas y estilos de aplicación dependiendo de la necesidad del proyecto. Trabaja con versiones de JDK superiores al 8. A demás nos provee diferentes entornos de trabajo:

    • Despliegue en un servidor propio
    • Despliegue en servidor embebido
    • Despliegue en la nube

    Dentro de estos entornos nos provee una estructura modular, es decir que iremos conectando las diferentes piezas que requiera nuestra aplicación.

    Trabajando con Spring Boot

    Spring Boot nació como respuesta a las exigencias de los estándares de la comunidad de desarrollo, por este motivo intrínsecamente implementa estándares y buenas practicas, al  igual que nos propone la siguiente filosofía de diseño:

    1. Establecer altos estándares de calidad para el código.
    2. Preocúpese por el diseño de la API.
    3. Mantenga compatibilidad con versiones anteriores.

    Estas reglas las ofrece de manera automática, es decir que se implementan casi al instante, esto se logra a través de, como mencionamos antes, conectar diferentes módulos(inyección de dependencias). A demás implementa estas reglas en su propio desarrollo a partir de ser un framework que ofrece opciones en todos los niveles de aplicación y se acomoda a las diversas necesidades.

    Los módulos de Spring Boot están orientados de tal manera que podamos identificar tres capas principales:

    • Capa de presentación.
    • Capa de Negocio.
    • Capa de persistencia.

    Esta forma de trabajo modular es la que lo convierte en uno de los mas populares frameworks para Java, a demás de otros subsistemas de los cuales no hemos mencionado, como : logging, web services, seguridad, automatización de pruebas, entre otros.

    Spring Boot permite a los desarrolladores enfocarse mas en la lógica de negocio y menos en problemas de plomería.

    Conceptos claves

    Inyección de dependencias

    La inyección de dependencias es un patrón de diseño en donde se le suministran objetos a una clase en lugar de ser la propia clase quien los crea.

    Bean

    El Core de Spring Boot es un contenedor que se encarga de orquestar beans(objetos gestionados). Estos beans son objetos de tipo POJO, es decir que son clases simples con sus atributos privados a los cuales se pueden acceder por métodos get y set.

    Cumpliendo con el patrón de inyección de dependencias, proveemos estos beans a los módulos de Spring Boot indicándole su forma de instanciación y correlaciones entre ellos; el Core se encargara de implementarlo.

    Inversión del control

    Este principio de software es uno de los pilares de Spring Boot, consiste en darte el control de los objetos al propio framework, es decir que el framework será el encargado de instanciar nuestras clases y reproducir el comportamiento que deseamos a partir de la configuración que le seteamos.

    Las principales ventajas de este principio es que logra modularizar nuestra aplicación permitiendo tener nuestra lógica compacta y aislada, repercutiendo en la mantenibilidad y facilidad de implementación de pruebas.

    Para implementar este principio(IoC, Inversion of Control) se utiliza en Spring Boot la inyección de dependencias, anteriormente ya lo habíamos mencionado, para ver la diferencia vamos a plantear un ejemplo:

    Código tradicional

    public class Person {
        private Document document;
        
        public Person() {
            document = new Document();
        }
    }

    Inyección de dependencias

    public class Person {
        private Document document;
        
        public Person(Document document) {
            this.document = document;
        }
    }
    ApplicationContext

    El ApplicationContext es una interfaz que nos permite implementar IoC, es decir, la instanciación  y el control del ciclo de vida e interacción entre objetos. Se encarga de procesar nuestros beans.

    Spring provee diferentes implementaciones de esta interfaz:

    • ClassPathXmlApplicationContext
    • FileSystemXmlApplicationContext
    • WebApplicationContext

    El proceso de implementacion de, por ejemplo, ClassPathXmlApplicationContext es:

    1. Crear archivo de configuración XML(/src/main/resources/beans.xml) para los beans.
      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      
          <bean id="personService" class="com.jhontona.service.PersonServiceImpl" />
      </beans>
    2. Implementar el ApplicationContext, en este caso en las pruebas unitarias(/src/test/java/com/person/service/PersonServiceTest.java)
      package com.person.service;
      import static org.junit.jupiter.api.Assertions.assertNotNull;
      
      import org.junit.jupiter.api.BeforeEach;
      import org.junit.jupiter.api.Test;
      import org.springframework.context.support.ClassPathXmlApplicationContet;
      
      public class PersonServiceTest {
          private ClassPathXmlApplicationContext context;
          private PersonService service;
      
          @BeforeEach
          void setUp() {
              context = new ClassPathXmlApplicationContext("beans.xml");
              service = context.getBean("personService", PersonService.class);
          }
      
          @Test
          void testGetOnePerson() {
              assertNotNull(service);
          }
      }

    Este archivo de beans.xml podemos personalizarlo dependiendo de nuestras necesidades, por ejemplo, podemos colocarle uno o varios alias a nuestro bean:

    <bean id="personService" name="alias1,alias2" class="com.jhontona.service.PersonServiceImpl" />

    Al bean le podemos indicar acceder a un constructor especifico o un método setter, ejemplo:

    Constructor

    public PersonService(String name, Integer age, Boolean document) {
    <bean id="personService" class="com.jhontona.service.PersonServiceImpl">
        <constructor-arg name="document" value="true"/>
        <constructor-arg index="0" value="Juanito"/>
        <constructor-arg value="19"/>
    </bean>

    Estos atributos los podemos pasar por nombre, índice, tipo u orden de los argumentos.

    A demás, podemos tener tantos beans como queramos. y hacer referencia entre ellos con el atributo ref.

    Hasta aquí esta breve introducción a Spring Boot, vimos algunos puntos claves a cerca del ecosistema de Spring.

  • JavaCup – Aprender Java mientras te diviertes!

    JavaCup – Aprender Java mientras te diviertes!

    Lamentablemente el evento de Javacup desapareció. Aunque JavaHispano avisará si hay una nueva edición.

    Este es uno de los mejores eventos y competencias que hay a nivel internacional de programación, lo mejor es que el ingreso es gratuito, el apoyo es constante y el aprendizaje es genial.

    JavaCup es un evento que se celebra cada año gracias a la comunidad de javaHispano y al patrocinio de Codemotion. Este año (2013) he participado por primera vez en su sexta versión y la experiencia a sido genial, a la fecha los partidos se están ejecutando y se pueden ver desde la pagina oficial.

    La comunidad de javaHispano desarrolló un framework que facilita al máximo el desarrollo del objetivo del concurso. Crear un equipo virtual de fútbol (desarrollar una clase Java que implementa una interfaz predefinida), como en el fútbol el objetivo es anotar goles y seguir avanzando. Esto se logra creando una buena táctica, es decir realizando una correcta programación que se adapte a cada posible situación.

    Para probarlo solo debes descargar el framework, pero si deseas participar debes registrarte, pero no te preocupes, la inscripción es muy sencilla, solo debes estar atento a las fechas en que se abren las convocatorias y colocar una información básica.

    Cuando descargas el framework vienen muchos ejemplos, las clases implementadas por los equipos que han participado anteriormente. Esto te facilita aun mas la implantación de los métodos a tu clase. Pero ahí no acaba, además cuentas con una documentación excelente y un foro muy activo.

    Para comenzar a realizar la táctica del equipo debes descargar el proyecto de la pagina, esta disponible para NetBeans y Eclipse, lo único que debes hacer es abrir el proyecto y ejecutar la interfaz que creara la clase base para crear la táctica.

    Me siento mas a gusto trabajando con NetBeans, así que utilice este, no pude dedicar mucho tiempo al desarrollo de la táctica, en realidad fueron como 2 horas, y obviamente esto se ve reflejado en los resultados de los partidos.

    Espero poder participar y generar mejores tácticas en las posteriores versiones, y te invito a que te animes a probarlo y ser parte de esta genial comunidad, Ahhhh, apropósito hay un buen premio en efectivo para los 4 primeros lugares, así que además de aprender, divertirte y programar participas por los premios.

    A continuación dejo el vídeo de mi primer partido. Quisiera decir que fue mejorando pero no fue así. Jaja, Seguro a la vuelta será mejor.

¡Hola a todos los entusiastas de la tecnología! Quería informarles que en mi blog utilizamos cookies para mejorar la experiencia de usuario. Estas pequeñas herramientas nos ayudan a personalizar el contenido y ofrecer funciones específicas. Al continuar explorando el sitio, aceptas nuestro uso de cookies. Puedes obtener más información sobre cómo las utilizamos en nuestra política de privacidad. ¡Gracias por ser parte de esta comunidad tecnológica! 🍪    Más información
Privacidad