
Guía paso a paso de **cómo crear un proyecto en blanco**, como plantilla para comenzar cualquier
desarrollo web. En este tutorial utilizamos Java y Spring Boot para construir una aplicación web
desde cero con sencillos pasos usando SpringBoot Initializr.

## Cómo crear una aplicación con SpringBoot Initializr

![](/post/045/initializr01_045.png)

Por parte de los desarrolladores de Spring, se tiene a disposición una herramienta web online
denominada **Spring Initializr** donde por medio de unos parámetros de configuración genera
automáticamente un proyecto **Maven o Gradle**, según se elija, en un archivo comprimido Zip
conteniendo la carpeta con la estructura de la aplicación para ser importada directamente desde el
editor de programación como Eclipse IDE, Netbeans IDE o Intellij.

Se puede acceder mediante el enlace a la dirección:
[https://start.spring.io/](https://start.spring.io/)

El asistente web solicita una serie de datos necesarios para poder ejecutar la plantilla que
construye los primeros archivos del programa. Para todos ellos aporta **una configuración por
defecto que conviene cambiar**, como el nombre de la aplicación, o el package que se usará en las
clases generadas.

A continuación se explica qué parámetros hay y para qué sirven:

-   **Project:** Permite elegir la herramienta de construcción de la aplicación. En Java las dos
    herramientas más usadas son Maven y Gradle. Recomendamos Maven al ser la más expendida.
-   **Language:** Lenguaje de programación que se va a utilizar en la aplicación. Los tres tipos
    están soportados por la máquina virtual JVM. Java es la opción más extendida y tiene mejor
    soporte de los editores de programación.
-   **Spring Boot:** Versión del Spring Boot a usar. Siempre que se pueda se optará por la última
    estable, compuesta únicamente por números.
-   **Project Metadata, Group:** Se refiere al descriptor de Maven groupId, utilizado para
    clasificar el proyecto en los repositorios de binarios. Normalmente se suele usar una referencia
    similar a la de los packages de las clases. Por ejemplo, com.arteco.web para disponer todas las
    aplicaciones web en el mismo directorio.
-   **Project Metadata, Artifact:** Se refiere al otro descriptor de Maven artifactId, y por tanto
    para indicar el nombre del proyecto y del binario resultante. La combinación de groupId y
    artifactId (más la versión) identifican inequívocamente a un binario dentro de cualquier
    organización.
-   **Packaging:** Indica qué tipo de binario se debe construir. Si la aplicación se ejecutará por
    sí sola se seleccionará JAR, éste contiene todas las dependencias dentro de él y se podrá
    ejecutar con **java -jar binario-<version>.jar**. Si por el contrario, la aplicación se
    ejecutará en un servidor J2EE existente o en un Tomcat ya desplegado se deberá escoger WAR.
-   **Java:** Se selecciona la versión de Java a usar. En este caso, se recomienda usar la versión
    de Java más antigua para garantizar la compatibilidad con otras librerías o proyectos que se
    quieran incluir, así será más probable encontrar documentación existente que siga siendo válida.
    Reduce el riesgo de toparse con funcionalidades no muy maduras.
-   **Dependencies:** Buscador de dependencias con los starters de Spring boot disponibles. Las
    dependencias más habituales son:
    -   **Spring Web** se deberá escoger cuando se desee hacer una aplicación web o microservicios,
        siempre que se requiera una comunicación http y por tanto el uso de Spring MVC.
    -   **Thymeleaf** Incorpora el motor de plantillas para HTML dinámico, sucesor de los anteriores
        JSP (Java Server Page).
    -   **Spring Data JPA** necesario para utilizar la capa estándar de acceso a base de datos SQL
        denominada Java Persistence Api.
    -   **Spring Security** Permite incorporar controles de acceso en base a usuarios y roles sobre
        URLs de la aplicación. También habilita el control de ejecución de métodos de servicio en
        base a roles según los estándares J2EE.
    -   **Lombok** Aporta utilidades que facilitan la programación como la creación de @Getters y
        @Setters automáticamente para las clases que forman parte del conjunto de mensajes.
    -   **Flyway** Librería que permite aplicar scripts de cambios de base de datos de manera
        controlada cuando arranca la aplicación. Estos scripts se denominan migraciones y están
        sujetos a un control de versiones para garantizar que se aplican en el orden correcto.
    -   **Mysql/Postgresql** Incluye el JAR que contiene el driver JDBC necesario para configurar la
        capa de JPA según la base de datos a usar.
    -   Otras… El asistente permite seleccionar entre más de 50 dependencias e integraciones de
        herramientas open source dentro de los proyectos realizados con Spring.

Una vez seleccionados los parámetros que se quieren, haciendo click en el botón **«Generate-Ctrl+»**
se descargará un archivo zip con el nombre del Artifact que contendrá la carpeta con la estructura
de la aplicación lista para importar desde el IDE.

## Recursos generados por SpringBoot Initializr

Para realizar la importación, bastará con importar o **abrir el fichero pom.xml** que viene dentro
del comprimido. Los editores crearán y configurarán el classpath y las librerías que se indican en
él para que estén disponibles para el programador.

El contenido del fichero tendrá la siguiente forma:

```
.
├── HELP.md
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
├── main
│  ├── java
│  │  └── org
│  │      └── eadp
│  │          └── spring
│  │              └── SpringAppApplication.java
│  └── resources
│      ├── application.properties
│      ├── static
│      └── templates
└── test
└── java
└── org
└── eadp
└── spring
└── SpringAppApplicationTests.java
```

De los ficheros incluidos, el más importante es **MyWebAppApplication.java** que corresponde con el
punto de entrada a la ejecución del programa. Aquí es donde se aloja el método _public static void
main(String\[\] arg)_ que es el que inicializa toda la aplicación de Spring Boot.

Durante el arranque del framework, Spring revista el resto de directorios o paquetes que cuelgan de
método **main** en búsqueda de clases marcadas con alguna anotación que permite el registro de
componentes como: @Service, @Component, @Repository y demás anotaciones de Spring y de Spring MVC
como @Controller o @RestController. Fíjese que el paquete utilizado es el _com.eadp.web_, esta
opción puede especificarse en el asistente Spring Initializr.

El siguiente fichero más importante es **application.properties** que es donde se aloja toda la
configuración de los componentes de Spring Boot, cómo que encoding usar (utf-8), si debe usar caché
en las plantillas, qué nombre y clave de acceso son los de por defecto, etc… En el enlace de
[configuraciones y propiedades comunes de spring boot](https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html)
hay una referencia de todas las existentes y sus valores iniciales.

El siguiente fichero es **MyWebAppApplicationTests.java** donde se aloja el primer test de ejemplo
que genera Initializr por nosotros. Ahí, el usuario debe añadir los test que considere oportunos
para aplicar en la medida de lo posible
[desarrollo orientado a test o TDD](https://www.arteco-consulting.com/introduccion-a-tdd/).

Los otros directorios son **static** que es donde se alojan los recursos estáticos que la aplicación
debe servir sin procesar. Por ejemplo en esta carpeta se incluyen los ficheros CSS, Javascript,
imágenes o fuentes que se referencian desde el HTML.

Si el fichero alojado en este directorio está en una sub-carpeta de static, como puede ser
static/css/main.css. **Spring Boot lo publicará automáticamente** en la url
http://localhost:8080/css/main.css. Así que no debe haber información sensible que cuelgue del
directorio static porque entonces será accesible abiertamente.

Y por último la carpeta **templates** almacena los ficheros que permiten generar HTML dinámicamente
con algún motor de plantillas soportado por Spring como Thymeleaf o Freemarker.

## Cómo añadir funcionalidad al proyecto

El proyecto creado es muy simple, si tratamos de arrancar el método _main_ de la clase
MyWebAppApplication, veremos cómo Spring inicializa toda la aplicación y se pone a la escucha del
puerto 8080, pero si dirigimos el navegador a esa URL no aparecerá ningún contenido. Así que veamos
cómo podemos hacer para imprimir algunos datos mediante html dinámico.

Para que las siguientes líneas sirvan debemos asegurarnos de haber escogido al menos las
dependencias de **Spring Web** y **Thymeleaf**, dejando el resto de opciones como se indican en las
líneas superiores. Generamos el proyecto de nuevo, de no ser así y crearemos el primer controlador
que permitirá añadir código Java y una plantilla Thymeleaf que generará los primeros documentos HTML
dinámicos.

Con el proyecto ya importado en el editor vamos a **crear un primer controlador** que será el
encargado de ejecutar código Java dada una URL. En éste crearemos una variable que podrá ser impresa
en la plantilla mediante el traspaso del dato vía el modelo.

```java
// contenido del fichero: src/main/java/org/eadp/spring/controller/MyController.java
package org.eadp.spring;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.time.LocalDateTime;

@Controller
public class MyController {

    @GetMapping("/")
    public String index(Model model) {
        model.addAttribute("tstamp", LocalDateTime.now());
        return "index";
    }
}
```

El controlador registra un método en «/», la raíz del sitio, de tal manera que cuando la aplicación
esté arrancada y lista para escuchar peticiones http, normalmente por el puerto 8080, el método
index será ejecutado cuando se solicite la URL de inicio http://localhost:8080/. En ese momento, el
método será ejecutado añadiendo la hora actual a una variable con nombre **tstamp** que se guarda en
model, objeto que se pasa a la vista, para que pueda construir el html dinámicamente. En este caso,
mostrando la hora en la que se invocó ese método.

Por otro lado, nada más ejecutarse el método del controlador, Spring pasará el control a la vista
con nombre **index** correspondiente al fichero _index.html_ de la carpeta de templates, tal y como
indica el _return «index»_, en el que no hace falta indicar la extensión .html.

Para completar el círculo y ver los resultado necesitamos crear la vista **index.html** con el
siguiente contenido:

```html
// contenido del fichero: src/main/resources/templates/index.html
<!DOCTYPE html>
<html lang="es" xmlns:th="http://www.thymeleaf.org">
    <head>
        <title>My First Spring Boot App</title>
        <style>
            html {
                font-family: "DejaVu Sans", Arial, Helvetica, sans-serif;
                color: #404040;
                background-color: #d3d3d3;
            }
            body {
                padding: 5em;
            }
        </style>
    </head>
    <body>
        <h1>Hello from Spring Boot!</h1>
        <p>This page is served at <span th:text="__$_{__tstamp}"></span></p>
    </body>
</html>
```

Y listos! Ahora ya podemos arrancar de nuevo la aplicación y hacer la petición a
http://localhost:8080/. Dando como resultado la impresión de la hora en la que se ejecutó el
controlador.


Spring Boot, el Web FRAMEWORK más utilizado en el entorno de Java. Utilizado por miles de empresas y mantenido por la comunidad BATTLE-TESTED

Tu primera Aplicación con SPRING BOOT - //Arteco

Iniciación a Spring Boot


## Cómo instalar Java en Ubuntu

![](/post/044/ubuntu_java_instalacion_044.png)

En el artículo anterior te enseñamos a
[instalar Ubuntu](https://www.arteco-consulting.com/introduccion-ubuntu/), el sistema operativo Open
Source alternativo a Windows preferido por los programadores. Si ya lo tienes instalado puedes
seguir los siguientes pasos para disponer del compilador y la máquina virtual de Java en tu
computadora.

La instalación de Java en Ubuntu es realmente sencilla, puesto que la comunidad prepara los paquetes
de OpenJdk con los binarios necesarios y los alojan en los repositorios públicos de software listos
para ser incorporados en nuestro sistema vía **apt**. Para ello abrimos un terminal de comandos y
ejecutamos el comando siguiente:

```
sudo apt install openjdk-8-jdk
```

El proceso realizará la descarga y configuración del nuevo paquete de las herramientas de
compilación y ejecución de programas Java listo para ser ejecutado por el usuario. Puede verificarse
que el proceso ha ido correctamente ejecutando de nuevo en la consola esta siguiente orden:

```
java -version
```

Dando como salida la correcta ejecución y versión de la máquina virtual de java JVM:

```
openjdk version "11.0.6" 2020-01-14
OpenJDK Runtime Environment (build 11.0.6+10-post-Ubuntu-1ubuntu118.04.1)
OpenJDK 64-Bit Server VM (build 11.0.6+10-.., mixed mode, sharing)
```

En el momento de escribir este post, en los repositorios oficiales de Ubuntu hay dos versiones
disponibles de Java, la versión 8 y la 11. Por defecto Ubuntu usará la más reciente, pero **se puede
forzar el uso de una versión en concreto** como la 8 de manera sistemática con:

```
sudo update-alternatives --config java

# O indicando una versión concreta con:
sudo update-java-alternatives --set /path/to/java/version
```

## Descargar Java para Win/Mac

Para instalar las herramientas de programación de Java se debe descargar y **ejecutar el instalador
de Java Development Kit**. Sin embargo, hay varias distribuciones del JDK y se deberá escoger uno u
otro en función de la versión de Java que se desee. Las versiones publicadas antes del 16 de abril
del 2019 están disponibles totalmente gratis vía la página de Oracle, requiriendo hacer login en su
sistema. Después de esa fecha los distribuibles ofrecidos por Oracle tienen un coste por uso. Así
que **para evitar los costes se debe acudir a los distribuibles de OpenJDK**, salvo que se desee una
versión anterior al 16 de abril del 2019.

Resumiendo, para obtener el compilador de Java se debe acudir a:

-   Última versión estable:  
    [Sitio web para escoger diferentes versiones de Java – Adopt JDK](https://adoptopenjdk.net/)

Según la plataforma donde se desea instalar se deberá descargar el binario correspondiente. **Las
computadoras modernas usan procesadores de 64bits**, éstas deberán descargar el instalador con
sufijo «x64». Por ejemplo para Windows sería «jdk-8u241-windows-x64.exe», mientras que para Mac
debería ser «jdk-8u241-macosx-x64.dmg». Sin embargo, si dispone de un ordenador más antiguo debe
seleccionar alguno terminado en «i586» correspondiente a las arquitecturas de 32bits.

## Cómo instalar Java en Windows

![](/post/044/win_env_vars_044.png)

Una vez descargado el JDK siguiendo las instrucciones del paso anterior, ejecutaremos el instalador
que procederá a la copia de los ficheros en la ubicación predeterminada. Aunque puede variarse, por
defecto se ubicarán los archivos en **c:\\Archivos de Programa\\Java\\jdk…**. Bastará dejar las
opciones tal y como vienen y continuar el asistente de instalación hasta finalizar el proceso.

Ya sólo quedará un último paso y es añadir una **variable de entorno** y editar otra existente para
que podamos invocar al compilador con **javac** o a la máquina virtual de Java con **java** desde
cualquier directorio.

Por tanto, en Windows dejaremos las siguientes variables de entorno como se indica a continuación:

-   **Crear la variable JAVA_HOME:**  
    JAVA_HOME=c:\\Archivos de Programa\\Java\\<jdk_instalado>
-   **Añadir JAVA_HOME al Path**  
    Path=%JAVA_HOME%\\bin;%Path%;

A partir de este momento, cada vez que desde el terminal o consola de comandos introduzcamos las
instrucciones de compilación y ejecución de programas Java, Windows sabrá dónde ir a buscar los
ejecutables correspondientes.

## Cómo instalar Java en Mac OSX

![](/post/044/mac_env_vars_044.png)

Una vez descargado el JDK siguiendo las instrucciones del paso anterior, ejecutaremos el instalador
que procederá a la copia de los ficheros en la ubicación predeterminada. Aunque puede variarse, por
defecto se ubicarán los archivos en **/Library/Java/JavaVirtualMachines/<jdk_instalado>**. Bastará
dejar las opciones tal y como vienen y continuar el asistente de instalación hasta finalizar el
proceso.

Ya sólo quedará un último paso y es añadir una **variable de entorno** y editar otra existente para
que podamos invocar al compilador con **javac** o a la máquina virtual de Java con **java** desde
cualquier directorio.

Por tanto, en Mac dejaremos las siguientes variables de entorno como se indica a continuación a
través de la edición del fichero **~/.profile** (recuérdese que la tilde de la eñe significa el
directorio home del usuario):

```
vi ~/.profile
```

Añadir las siguientes filas:

```
export JAVA_HOME=/Library/Java/JavaVirtualMachines/<jdk_instalado>
export PATH=$JAVA_HOME/bin:$PATH
```

El contenido de esas líneas declara y exporta la variable JAVA_HOME para que esté disponible durante
la sesión de la terminal y añade el directorio de los binarios de java al Path por delante del resto
de directorios que contiene el path.

A partir de este momento, cada vez que desde el terminal o consola de comandos introduzcamos las
instrucciones de compilación y ejecución de programas Java, Windows sabrá dónde ir a buscar los
ejecutables correspondientes.

## Cómo tener varios JDKs

Para tener varios JDKs sólo debe tenerse en cuenta las variables de JAVA_HOME y Path (PATH en
unix/linux). Tras proceder con la instalación de dos o más Jdks y que no haya conflictos entre ellos
bastará asegurarse que el Path siempre tiene en su contenido, la expresión que apunta al directorio
%JAVA_HOME%\\bin en Windows, o $JAVA_HOME/bin en Linux/Mac. Así, cuando se quiera cambiar de un JDK
a otro, lo único que hay que hacer es ajustar la variable JAVA_HOME para que apunte al JDK deseado.

Para ajustar los valores de la variable en **Windows** de forma temporal puede usarse el comando
**SET**, y si se desea que sea permanente el cambio se deberá ir a la utilidad de edición de
variables de entorno ya citado. De forma temporal pondremos lo siguiente:

```
SET JAVA_HOME=c:\Archivos de Programa\Java\<jdk_alternativo>
```

El comando SET podemos ejecutarlo tantas veces como deseemos para cambiar el JDK, eso sí, sólo tiene
de ámbito la sesión actual del terminal de comandos.

Para sistemas **Linux y Mac** deberemos usar **export** para proceder con el cambio del valor de las
variables.

```
export JAVA_HOME=/opt/java/<jdk_alternativo>
```

En estos mismos sistemas basados en unix, si se desea que el cambio sea permanente editaremos el
fichero alojado en el home del usuario con nombre **.profile**. Para editar este fichero puede
hacerse cómodamente con **vi**

```
vi ~/.profile
```

Añadiendo la siguiente fila

```
export JAVA_HOME=/opt/java/<jdk_alternativo>
export PATH=$JAVA_HOME/bin:$PATH
```

El símbolo «~» representa el home del usuario en sistemas Unix. Fíjese que en estos sistemas el
separador de directorios no es punto y coma como en Windows, si no dos puntos.

## Siguiente paso – otras herramientas

Llegados a este punto ya tenemos parte del trabajo hecho para poder programar en Java como
profesionales, pero nos quedará
[instalar Maven el gestor de dependencias](https://www.arteco-consulting.com/post/instalacion-de-maven)
y de construcción de aplicaciones Java. Adicionalmente, deberemos
[instalar un buen IDE](https://www.arteco-consulting.com/post/instalar-editor-integrado-de-java) y
por último y no menos importante
[un gestor de versiones como git](https://www.arteco-consulting.com/post/instalar-git-en-win-linux-y-mac).


Sigue los sencillos PASOS para instalar GRATIS las herramientas de programación de JAVA y comienza a desarrollar tus primeras aplicaciones

Cómo INSTALAR las herramientas de JAVA para programar - //Arteco

Como instalar Java

Es el sistema preferido por los PROGRAMADORES. Es GRATUITO y tiene una gran colección de herramientas que usan todos los PROFESIONALES

Cómo INSTALAR y USAR Ubuntu desde cero - //Arteco

Cómo instalar Ubuntu


## Qué es un Java IDE

Las siglas de IDE significan _Integrated Development Environment_ o lo que es lo mismo **Entorno
Integrado de Programación**. Básicamente es un término que se atribuye a editores de texto a los que
se les han añadido muchas funcionalidades y accesos rápidos para realizar tareas típicas del
programador. Además son algo inteligentes e indexan el contenido de los ficheros fuente, permiten
ejecutar paso a paso los programas mostrando el detalle del avance en la ejecución y tienen
integraciones con otras herramientas habituales como los sistemas de control de versiones como git,
o incluso gestores de incidencias para tramitar tiquets de errores o de peticiones de cambio
realizados por los usuarios.

Aunque no es totalmente obligatorio, **su uso es más que recomendable** utilizar uno que incorpore
soporte nativo con el lenguaje de programación que se utilizará para desarrollar los programas,
páginas web o aplicaciones móviles que se deseen.

Afortunadamente todos los **propuestos son gratuitos** y además son Open Source contrariamente con
lo que pueda parecer. Hay miles de empresas y programadores que mantienen estos editores
actualizados añadiéndoles innovaciones por su gran implantación que hay en todos los sectores,
evitando posiciones dominantes en el mercado o manufacturadores que apliquen licencias o royalties
al considerarse tan o más críticos que el propio lenguaje de programación, por el coste que tiene el
desarrollo al tener que contratar personal especializado con salarios bien remunerados.

## Qué editor de programación elegir

![](/post/041/escoger_ide_041.png)

Dentro del conjunto de IDEs gratuitos, la mayoría Open Source, se dividen en dos grandes familias.
Los genéricos que permiten editar ficheros en general, sin estar especializados en ningún lenguaje,
pero altamente configurables y adaptables. Estos incluyen el acceso a pequeños programas que los
completan denominados _plugins_ que ajustan el comportamiento al lenguaje o herramientas utilizadas.

Con cualquiera de los editores genéricos el usuario podrá realizar actividades de programación, pero
debe saber que tendrá una penalización en su rendimiento considerable en cuanto al tiempo invertido,
respecto a otro que use un buen editor con todas las baterías incluidas. Además, estos IDEs
avanzados también son gratis, ¿por qué no aprender a usar uno?

En el listado de **editores de programación genéricos** aparecen los siguientes:

-   [Visual Studio Code (VSCODE)](https://code.visualstudio.com/)
-   [Atom](https://atom.io/)
-   [Brackets](https://brackets.io/)
-   [Sublime](https://www.sublimetext.com/) (Freeware)

Sin embargo, **recomendamos un IDE especializado en proyectos Java**, que disponga de integración
nativa con Maven para simplificar al máximo las actividades que tendremos que realizar como
programadores.

Si nos centramos en los **IDEs especializados en Java** el listado recomendado es el siguiente:

-   [Intellij IDEA Community](https://www.jetbrains.com/es-es/idea/download/)
-   [Eclipse Desktop IDE for Java Developer](https://www.eclipse.org/eclipseide/)
-   [Apache Netbeans](https://netbeans.apache.org/)

**Cualquiera de los tres editores citados será suficiente** para realizar aplicaciones en Java,
todos ellos incluyen soporte de Maven y Git nativamente. No se requerirá instalar ningún plugin o
software de terceros para añadir la funcionalidad necesaria. Esto no será así si se usa algún editor
genérico como: VSCODE, Sublime, Atom o Brackets.

## Instalar un IDE Java en Ubuntu

![](/post/041/instalar_ide_041.png)

Los repositorios de Ubuntu simplifican al máximo las tareas de instalación y en ellos están alojados
los principales editores de programación. Para ello simplemente se ha de abrir el icono de
**Software de Ubuntu** y buscar **Java IDE**.

Acto seguido nos aparecerán las distintas opciones correspondientes con los principales editores de
programación más usados en Java: **IDEA Community**, **Eclipse** y **Apache NetBeans**. Bastará
seleccionar cualquiera de ellos y el sistema procederá automáticamente a la descarga e instalación
del software solicitado.

## Instalar un IDE para Java en Windows o Mac

La instalación de cualquiera de los IDEs indicados: Idea, Eclipse o Netbeans, **será suficiente con
acceder a la página indicada en el listado y descargar el instalador correspondiente** al sistema
operativo que tengamos y la arquitectura del pc. La mayoría de ellos requerirá un PC relativamente
moderno con procesador de 64Bits.

Es recomendable tener un disco duro SDD y al menos 8Gb de RAM para que el sistema responda con
fluidez en las operaciones de compilación y ejecución de programas. Si no tienes un equipo adecuado,
recuerda que un buen profesional necesita unas buenas herramientas.

-   [Intellij IDEA Community](https://www.jetbrains.com/es-es/idea/download/)
-   [Eclipse Desktop IDE for Java Developer](https://www.eclipse.org/eclipseide/)
-   [Apache Netbeans](https://netbeans.apache.org/)

El instalador de cualquiera de los editores dejará como resultado un icono sobre el escritorio para
acceder rápidamente a la ejecución del editor.

## Siguiente paso – empezar a programar

Llegados a este punto ya podemos ponernos manos a la obra y realizar un primer programa en Java con
las herramientas necesarias. Recuerde que para poder realizar el primer programa necesitará tener
[instalado el JDK de Java](https://www.arteco-consulting.com/post/instalar-java) que aporta todas
las herramientas de programación y ejecución de Java. También será necesario
[instalar Maven el gestor de dependencias](https://www.arteco-consulting.com/post/instalacion-de-maven)
y de construcción de aplicaciones Java. Adicionalmente deberemos incluir
[un gestor de versiones como git](https://www.arteco-consulting.com/post/instalar-git-en-win-linux-y-mac)
para tener copias de seguridad y un mecanismo de sincronización entre PC o entre un equipo de
programación.


Averigua qué opciones GRATUITAS hay para comenzar a programar en Java como un profesional desde cero hasta la creación de aplicaciones reales

INSTALA un buen EDITOR JAVA integrado para programar - //Arteco

Instalar un buen IDE Java


## Qué es Git

Git es un sistema de control de versiones distribuido. Al ser un sistema de control de versiones,
git hará un seguimiento de los archivos fuente que son necesarios para construir un el programa que
estemos editando. De tal manera que se añade un fichero, se modifica o se borra, **git guardará en
un registro interno cada uno de los cambios**. Esto permite poder consultar el estado del proyecto
en una determinada fecha, pudiéndolo recuperar tal y como estaba, aunque se hubieran borrado
ficheros. Que sea un sistema distribuido significa que cada copia del proyecto contiene todo el
histórico completo, hasta el momento en que se hizo la copia.

Si quiere aprender más acerca de esta herramienta consulte el
[tutorial de Git](https://www.arteco-consulting.com/tutorial-de-git/).

## Cómo instalar Git en Ubuntu

La instalación de git en Ubuntu **no puede ser más fácil**. Sólo hay que abrir un terminal de
comandos y ejecutar **apt** para que se descargue el paquete de los repositorios oficiales y
configure el sistema para dejarlo disponible.

Para ello instalaremos **git** y verificaremos que puede ejecutarse sin problemas:

```
sudo apt install git

# confirmación del comando
git --version
```

## Instalar Git para Windows

Git, creado por Linus Torvalds padre de Linux, es una aplicación con distribuibles preparados para
las principales plataformas. Sólo debe descargarse el instalador correspondiente desde la
[página oficial del proyecto Git](https://git-scm.com/downloads) y descargar el instalador
correspondiente al sistema operativo usado teniendo en cuenta la arquitectura de nuestro sistema: 32
o 64bits.

El instalador para Windows abrirá un asistente que mostrará una serie de opciones durante el
proceso. No debe preocuparse y dejar las opciones marcadas por defecto que serán suficientes en la
mayoría de las situaciones.

Una vez que el proceso haya terminado correctamente, compruebe la instalación ejecutando git de
prueba con:

```
git --version
```

## Instalar Git para Windows

La configuración de Maven para Windows es muy sencillo, lo único que debe hacer es descomprimir el
archivo Zip descargado del paso anterior y ubicando los ficheros en un directorio. Por ejemplo en el
directorio donde se ha almacenado los archivos del JDK: **c:\\Archivos de
Programa\\Java\\apache-maven-<version>**. Anote la ruta completa porque será necesaria en el
siguiente paso.

Una vez descomprimidos los archivos se deberá crear la variable de entorno **MAVEN_HOME** apuntando
a la ruta anterior, base de la instalación. El uso de esta variable permitirá cambiar de una
distribución de Maven a otra versión más actualizada sin tener que cambiar todas las referencias a
esta difundida por los proyectos.

Por último, añadiremos la ruta de los binarios de Java a la variable de entorno Path para que
podamos invocar a maven con el comando **mvn** desde cualquier directorio:

```
Path=%MAVEN_HOME%\bin;%Path%
```

Si la configuración está bien hecha, desde un terminal de comandos podremos invocar a maven a modo
de prueba con la siguiente instrucción:

```
mvn -version
```

Puede continuar el tutorial por el siguiente paso
[instalación de un editor Java](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/)

## Instalar Git para Mac OSX

La instalación de git para Mac tiene dos alternativas, la primer de ellas es utilizando el
instalador (archivo .dmg) publicado en la [página oficial de Git](https://git-scm.com/downloads) de
git para Mac. Sin embargo, no es la forma recomendada, ya que ante las actualizaciones de la
herramienta se requerirá realizar una instalación manual de nuevo, volviendo a descargar e ejecutar
el instalador publicado.

En entornos Mac se [recomienda el uso del gestor de paquetes homebrew](https://brew.sh/index_es) que
simplifica el proceso de instalación y mantiene actualizadas todas aquellas aplicaciones bajo su
registro. Además la mayoría de las instalaciones usando **brew** se realizan en el espacio de
usuario sin requerir acceso de super usuario en la computadora.

Para **instalar homebrew en Mac** se debe ejecutar la siguiente instrucción desde el terminal de
comandos, sacado de la página oficial del proyecto:

```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
```

Una vez instalado, basta usar _brew_ de forma similar al gestor de paquetes de Ubuntu _apt_:

```
brew install git
```

Pasados unos segundos la aplicación de gestión y control de versiones estará disponible globalmente
en nuestras sesiones de terminal. Podemos hacer una prueba con:

```
git --version
```

## Siguientes pasos

Para poder instalar el editor, recuerde que necesita disponer del
[JDK de Java](https://www.arteco-consulting.com/instalar-java/) para poder editar, compilar y
ejecutar una aplicación Java. Para la construcción del programa necesitará
[instalar Apache Maven](https://www.arteco-consulting.com/instalacion-de-maven/) que se hará cargo
también de la descarga y configuración de dependencias y librerías de terceros. Por otro lado
necesitaremos un buen
[editor de programación](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/) que
simplifique las tareas de edición de archivos Java. Si ya tiene todas las herramientas necesarias
[pruebe de crear el primer programa en Java](https://www.arteco-consulting.com/tu-primer-programa-java/)
siguiendo las instrucciones que le mostramos.


El sistema de CONTROL de VERSIONES más usado para vigilar el código fuente de cualquier proyecto de programación. Y es ¡GRATUITO!

Instala el CONTROL de CAMBIOS estándar Git - //Arteco

Cómo instalar GIT


Docker es un sistema de virtualización que **permite arrancar máquinas virtuales** en local o en un
servidor en Internet, cada una de ellas **con una aplicación o servicio** especializado, por ejemplo
para levantar una base de datos MySQL. Averigua cómo se hace.

## Qué es Docker

Docker es un **servicio de virtualización**, que se puede desplegar en local o en la nube, que
**permite gestionar contenedores virtuales**. Los contenedores son similares a máquinas virtuales,
pero que comparten algunas capas comunes para aliviar el trabajo de host o del servidor que debe
ejecutar todas ellas.

Cada contenedor normalmente tendrá **una aplicación pre-instalada** en lo que se denomina una
**imagen**. Los programadores y administradores de sistemas, construyen dicha imagen introduciendo
en ella la aplicación, ficheros de configuración y demás recursos, para poder arrancar o levantar un
contenedor que sea capa de ejecutar la aplicación.

Si quieres aprender más acerca de esta herramienta consulta nuestro
[tutorial de Docker](https://www.arteco-consulting.com/tutorial-de-docker/).

## Qué ventajas tiene usar Docker

Docker **simplifica enormemente arrancar aplicaciones pre-configuradas**, gracias a que la comunidad
ha dejado miles de servicios bien empaquetados en imágenes que fácilmente pueden ser arrancados en
un PC normal, como una base de datos MySQL o una aplicación Java con Spring Boot. Con pocos
conocimientos un usuario avanzado podrá empaquetar sus propias aplicaciones que podrá distribuir al
resto de usuarios.

Estas imágenes se pueden distribuir de forma local o de forma pública en Internet en unas
plataformas web llamadas registros o **registry** de manera similar a los repositorios de artefactos
de Maven. Para dar flexibilidad a las aplicaciones, éstas suelen aceptar parámetros en forma de
variables de entorno, que permiten adaptar la aplicación según el entorno. Por ejemplo, algunas
imágenes permiten ser parametrizadas con la dirección donde está ubicada la base de datos.

Otra de la gran ventaja del uso de Docker, es que a estos contenedores se les asignan **cuotas de
cpu, de memoria y disco** para mantenerlos aislados respecto al resto de procesos y contenedores que
se ejecutan en el host. Y típicamente se hace una redirección del tráfico de red con reglas TCP/IP
para que las comunicaciones entrantes del host se propaguen hasta el contenedor adecuado, ya sea
mediante el uso de puertos diferentes o mediante algún proxy reverso como
[Traefik](https://docs.traefik.io/) que usa diferentes nombres de dominios o rutas Http para
redirigir el tráfico.

## Cómo instalar Docker

Independientemente de si tienes Windows, Linux o Mac, la mejor manera de instalar Docker es **vía
los paquetes oficiales** preparados por el proyecto que proporcionan instaladores muy fáciles de
ejecutar. Todos ellos necesitan los permisos de administrador del equipo, ya que el software
requiere interactuar activamente con los servicios de red para la redirección del tráfico que se
origine o vaya destinado a cualquiera de los contenedores que administra.

Las únicas limitaciones que hay sobre la instalación de Docker es que tu pc o portátil debe tener
cierta capacidad y potencia. Por otro lado, en el caso de que seas usuario de Windows, deberás tener
la versión Professional para poder instalar Docker. Si no es así, visita el tutorial de
[instalación de ubuntu](https://www.arteco-consulting.com/introduccion-ubuntu/), el mejor sistema
operativo para programar totalmente gratis y Open Source.

A continuación dejamos los enlaces para proceder a la instalación según el sistema operativo usado:

-   [Docker para Ubuntu/Debian](https://docs.docker.com/install/linux/docker-ce/ubuntu/)
-   [Docker para Mac Osx](https://hub.docker.com/editions/community/docker-ce-desktop-mac)
-   [Docker para Windows](https://hub.docker.com/editions/community/docker-ce-desktop-windows)

## Cómo usar Docker / Compose

Una vez que Docker esté instalado en tu equipo, éste se estará ejecutando como un servicio en
segundo plano orquestando los diferentes contenedores que arranques. Obviamente, nada más instalar
Docker, no habrá ninguno ejecutándose, puedes probar **arrancar un contenedor de prueba** con la
siguiente orden en la consola de comandos:

```
docker run hello-world
```

Este comando lanzará una imagen de prueba que únicamente imprime un mensaje por consola y finaliza
el contenedor acto seguido. Como la imagen no estará disponible localmente, ésta será descargada de
los repositorios públicos de imágenes para poder pasar a ejecución.

```
docker : Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.
...
```

Si te ha ido bien, enhorabuena! Ya tienes en tu PC un gestor de contenedores con el que levantar
aplicaciones rápidamente. Ahora bien, **levantar un contenedor** puede requerir que previamente
exista otro, por ejemplo una aplicación que dependa de una base datos. O incluso, configurar una
imagen para que se adapte al entorno donde se va a ejecutar **puede requerir varios parámetros**.

Así que para simplificar el proceso se usa un fichero de configuración denominado
**docker-compose.yml** que es usado por una utilidad denominada **Docker Compose**. Ésta no es más
que una capa ligera por encima de Docker que traduce el fichero de configuración a invocaciones al
servicio de Docker. Conviene instalarlo y familiarizarse con la
[sintaxis Yaml](https://onthedock.github.io/post/170525-introduccion-a-yaml/) usada en estos
ficheros de configuración, ya que se usa mucho en todo lo que tiene que ver con virtualización.

Si eres usuario de Docker Desktop para Windows o para Mac, Docker Compose ya estará instalado. Pero
si eres **usuario de Ubuntu** o alguna distribución de Linux en general basta que ejecutes estos
comandos en la consola:

```
# descarga del script de docker-compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# habilitar permiso de ejecución al script
sudo chmod +x /usr/local/bin/docker-compose

# añadirlo a un directorio visible por la variable Path
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
```

A partir de este momento, podrás ejecutar **docker-compose** desde un terminal de comandos correcta
e independientemente de donde estés ubicado.

## Más acerca de Docker

Si quieres aprender más acerca de esta herramienta consulta nuestro
[tutorial de Docker](https://www.arteco-consulting.com/tutorial-de-docker/) o prueba de arrancar una
base de datos en local en un
[contenedor con MySQL](https://www.arteco-consulting.com/instalar-mysql-con-docker/) o otra del tipo
[PostgreSQL con Docker](https://www.arteco-consulting.com/instalar-postgresql-con-docker/).


Docker es el sistema más usado para levantar aplicaciones o servicios VIRTUALIZADOS de forma aisalada en CONTENEDORES con cuotas de recursos

Instala el VIRTUALIZADOR por excelencia DOCKER - //Arteco

Cómo instalar Docker


Levantar una base de datos con Docker **es la manera más rápida** de tener un entorno de
programación listo para empezar a programar en un PC doméstico, sin realizar instalaciones que dejen
restos de archivos y configuraciones a lo largo de todo el disco duro, simplificando enormemente los
entornos de desarrollo y producción.

¿Y cómo se hace? Pues de forma resumida, Docker es una plataforma de código abierto en forma de
máquina virtual que gestiona y ejecuta contenedores que empaquetan aplicaciones. What? Veamos el
detalle…

## Qué es Docker

Docker es un servicio de **virtualización de aplicaciones** dentro de unos denominados contenedores.
Esto permite que las aplicaciones se ejecuten independientemente del host que los alberga. Cuando
una aplicación está virtualizada su puesta en marcha por orquestadores que monitorizan el estado de
las aplicaciones y la carga que soportan, fácilmente pueden levantar o apagar instancias en la nube
para tolerar altas cargas de trabajo.

Docker está disponible sin coste, para las principales plataformas de escritorio y es una de las
herramientas básicas de todo programador moderno. Revisa el artículo de
[instalación de docker](https://www.arteco-consulting.com/instalacion-de-docker/) para dejar tu
estación de trabajo lista para desarrollar. O si quieres ampliar tus conocimientos acerca del uso de
ésta revisa nuestro [tutorial de Docker](https://www.arteco-consulting.com/tutorial-de-docker/).

## Requisitos para MySQL con Docker

Si eres usuario de Windows o Mac necesitarás tener instalado Docker Desktop en tu pc o portátil y
éste debe tener cierta capacidad y potencia. Por otro lado, en el caso de que seas usuario de
Windows, deberás tener la versión Professional para poder instalar Docker. Si no es así, visita el
tutorial de [instalación de ubuntu](https://www.arteco-consulting.com/introduccion-ubuntu/), el
mejor sistema operativo para programar totalmente gratis y Open Source. Si eres usuario de Ubuntu o
Debian asegúrate de tener en tu sistema **Docker Compose** también explicado en el tutorial de
instalación de Docker.

## Instalar MySQL con Docker

Para arrancar una base de datos MySQL con docker el proceso no puede ser más sencillo. Basta que
cojamos la plantilla del fichero de configuración de Docker Compose que dejamos a continuación e
invoques al comando que realizará todo el proceso.

```
version: '2'
services:
mysql:
image: 'mysql:latest'
restart: always
volumes:
- './mysql_data:/var/lib/mysql'
environment:
- MYSQL_ROOT_PASSWORD=secure_pass_here
ports:
- '3306:3306'
```

Guarda el fichero en local con el nombre **docker-compose.yml** en un directorio denominado
<home*usuario>/docker/mysql si estás en Unix, o <home_usuario>\\docker\\mysql si estás en Windows.
La configuración \*\*guarda los datos en el subdirectorio *./mysql*data*\*\* de forma
permanentemente, puesto que si no, en cada reinicio del contenedor se perderían las bases de datos
alojadas. Luego, posiciónate con un terminal de comandos en el mismo directorio que el fichero y
ejecuta:

```
docker-compose up -d
```

El sistema, primero descargará la imagen de los
[repositorios públicos de Docker](https://hub.docker.com/) al ver que no está disponible localmente
y luego procederá al arranque y a la apertura del puerto indicado en el fichero de configuración. La
opción _\-d_ indica a Docker que se ejecute el servicio en segundo plano.

A partir de ese momento, utiliza tu interfaz gráfico preferido para conectar a la base de datos. Si
no tienes ninguno puedes adquirir el
[cliente gratuito y multi base de datos DBeaver](https://dbeaver.io/).

## Verificar que el servicio MySQL está activo

Para verificar que el servicio está activo y el contenedor ejecutándose de forma normal, pruebe de
ejecutar el siguiente comando de docker que muestra los contenedores en funcionamiento:

```
docker ps
```

Deberá aparecer al menos una entrada correspondiente al contenedor MySQL en estado activo como se
muestra a continuación:

```
CONTAINER ID  IMAGE    COMMAND                 CREATED       STATUS       PORTS                               NAMES
327fd50443a7  mysql:5  "docker-entrypoint.s…"  29 hours ago  Up 6 hours   0.0.0.0:3306->3306/tcp, 33060/tcp   docker_mysql_1
```

De ser así, puede continuar con el resto de actividades, puesto que como se indica en el fragmento
de texto anterior, el contenedor se encuentra ejecutándose (status up) y escuchando en el
puerto 3306.

## Conectar MySQL con DBeaver

![](/post/039/mysql_dbeaver_039.png)

Si tenemos el cliente SQL **DBeaver**, una vez arrancado el contenedor, podremos conectarnos con
este cliente multi plataforma ingresando los siguientes datos:

```
Seleccionar nueva conexión para MySQL 8+
Server host: localhost
Port: 3306
User name: root
Password: secure_pass_here
```

A continuación darle «Probar conexión» y si todo ha ido bien, «Finalizar». A partir de ese momento
el cliente gráfico SQL podrá abrir una conexión con el contenedor mientras éste esté en ejecución.

Si no tienes mucha experiencia en el manejo de bases de datos como MySQL te recomendamos que
realices una lectura del [tutorial de SQL](https://www.arteco-consulting.com/tutorial-de-sql/) para
principiantes.

## Siguientes pasos

Llegados a este punto, ya estás preparado para desarrollar una aplicación con Java. Visita la página
de
[tutoriales y pasos para programar con Java](https://www.arteco-consulting.com/inicio-rapido-a-la-programacion/)
donde hemos recopilado todos los recursos necesarios para despegar tu carrera profesional como
programador.

Pero antes, conviene que
[crear una nueva base de datos y un usuario limitado con MySQL](https://www.arteco-consulting.com/gestion-de-usuarios-en-mysql/)
o con [PostgreSQL](https://www.arteco-consulting.com/gestion-de-usuarios-en-postgresql/) para no
conectar con el administrador, limitando así las acciones que pueden realizarse desde la aplicación.
Muy interesante sobre todo cuando hay varias bases de datos y aplicaciones conectadas al mismo
gestor, añadiendo una capa de seguridad más que conveniente.


Gracias a DOCKER podemos arrancar MYSQL en un CONTENEDOR sin ningún esfuerzo y de forma limpia y aislada controlando sus recursos

Cómo Instalar MYSQL con DOCKER en 5 minutos - //Arteco

Cómo instalar MySQL con Docker


## Qué es Apache Maven

Maven es una herramienta desarrollada en Java que **simplifica las tareas de compilación y
construcción** de aplicaciones de software, principalmente usado con lenguajes de programación que
tienen como destino ser ejecutadas en la Java Virtual Machine (JVM). Además, incorpora una **gestión
de dependencias** madura con acceso a los repositorios públicos de Maven con más de 16 Millones de
librerías disponibles incluyendo todas las versiones de cada una de ellas.

Si quiere aprender más acerca de esta herramienta consulte el
[tutorial de Maven](https://www.arteco-consulting.com/tutorial-de-maven/).

## Cómo instalar Maven en Ubuntu

De la misma manera que se ha procedido con la instalación del JDK, la herramienta de construcción y
de gestión de dependencias de proyecto Java por excelencia Maven se instalará de forma equivalente:

```
sudo apt install maven
```

Dando como resultado la instalación de comando **mvn** que podemos ejecutar desde cualquier
directorio. La manera de comprobarlo es solicitando que imprima la versión del mismo con

```
mvn -version
```

Si no ha habido ningún problema durante la instalación podremos ver un contenido similar al
siguiente:

```
Apache Maven 3.6.0
Maven home: /usr/share/maven
Java version: 11.0.6, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: es_ES, platform encoding: UTF-8
OS name: "linux", version: "5.3.0-42-generic", arch: "amd64", family: "unix"
```

Por último sólo queda instalar el editor de programación de Java que más nos interese

## Descargar Apache Maven para Win/Mac

Maven, al estar programado en Java, éste es portable, por lo que la misma distribución puede usarse
en cualquier plataforma que pueda ejecutarse la JVM. Así que únicamente debemos acceder a la
[página oficial del proyecto Maven](https://maven.apache.org/download.cgi) y descargar la última
versión estable. Ésta se ofrece en varios formatos, aquella que tiene extensión Zip será suficiente
en la mayoría de los casos.

Una vez descargada, revise la sección de su plataforma para ver cómo configurarlo correctamente.

## Configurar Apache Maven para Windows

La configuración de Maven para Windows es muy sencillo, lo único que debe hacer es descomprimir el
archivo Zip descargado del paso anterior y ubicando los ficheros en un directorio. Por ejemplo en el
directorio donde se ha almacenado los archivos del JDK: **c:\\Archivos de
Programa\\Java\\apache-maven-<version>**. Anote la ruta completa porque será necesaria en el
siguiente paso.

Una vez descomprimidos los archivos se deberá crear la variable de entorno **MAVEN_HOME** apuntando
a la ruta anterior, base de la instalación. El uso de esta variable permitirá cambiar de una
distribución de Maven a otra versión más actualizada sin tener que cambiar todas las referencias a
esta difundida por los proyectos.

Por último, añadiremos la ruta de los binarios de Java a la variable de entorno Path para que
podamos invocar a maven con el comando **mvn** desde cualquier directorio:

```
Path=%MAVEN_HOME%\bin;%Path%
```

Si la configuración está bien hecha, desde un terminal de comandos podremos invocar a maven a modo
de prueba con la siguiente instrucción:

```
mvn -version
```

Puede continuar el tutorial por el siguiente paso
[instalación de un editor Java](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/)

## Configurar Apache Maven para Mac OSX

La configuración de Maven para Mac OS es tan simple como en Windows, lo único que debe hacer es
descomprimir el archivo Zip descargado del paso anterior y ubicando los ficheros en un directorio.
Por ejemplo en el directorio donde se ha almacenado los archivos del JDK:
**/opt/apache-maven-<version>**. Anote la ruta completa porque será necesaria en el siguiente paso.

Una vez descomprimidos los archivos se deberá crear la variable de entorno **MAVEN_HOME** apuntando
a la ruta anterior, base de la instalación. El uso de esta variable permitirá cambiar de una
distribución de Maven a otra versión más actualizada sin tener que cambiar todas las referencias a
esta difundida por los proyectos.

```
export $MAVEN_HOME=/opt/apache-maven-<version>
```

Por último, añadiremos la ruta de los binarios de Java a la variable de entorno Path para que
podamos invocar a maven con el comando **mvn** desde cualquier directorio:

```
export PATH=$MAVEN_HOME/bin:$PATH
```

Si la configuración está bien hecha, desde un terminal de comandos podremos invocar a maven a modo
de prueba con la siguiente instrucción:

```
mvn -version
```

Recuerde que para hacer los cambios permanentes y no tener que invocar a **export** en cada sesión
del terminal, puede añadir ambas sentencias al fichero de inicialización el terminal ubicado en
**~/.profile**

Puede continuar el tutorial por el siguiente paso
[instalación de un editor Java](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/)

## Siguiente paso – Instalar un IDE

Para poder instalar el editor, recuerde que necesita disponer del
[JDK de Java](https://www.arteco-consulting.com/instalar-java/) para poder editar, compilar y
ejecutar una aplicación Java. Por otro, lado necesitaremos un buen
[editor de programación](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/) que
simplifique las tareas de edición de archivos Java. Y por último conviene incluir el
[sistema de control de versiones git](https://www.arteco-consulting.com/instalar-git-en-win-linux-y-mac/)
en nuestro proyecto para no perder ni una coma por error.


Maven es el programa por defecto para la GESTIÓN de DEPENDENCIAS y para la CONSTRUCCIÓN de aplicaciones JAVA modular de Apache

Cómo INSTALAR el constructor MAVEN para proyectos JAVA - //Arteco

Cómo instalar Maven


## Qué es Docker

Docker es un servicio de **virtualización de aplicaciones** dentro de unos denominados contenedores.
Esto permite que las aplicaciones se ejecuten independientemente del host que los alberga. Cuando
una aplicación está virtualizada su puesta en marcha por orquestadores que monitorizan el estado de
las aplicaciones y la carga que soportan, fácilmente pueden levantar o apagar instancias en la nube
para tolerar altas cargas de trabajo.

Docker está disponible sin coste, para las principales plataformas de escritorio y es una de las
herramientas básicas de todo programador moderno. Revisa el artículo de
[instalación de docker](https://www.arteco-consulting.com/instalacion-de-docker/) para dejar tu
estación de trabajo lista para desarrollar. O si quieres ampliar tus conocimientos acerca del uso de
ésta revisa nuestro [tutorial de Docker](https://www.arteco-consulting.com/tutorial-de-docker/).

## Requisitos para Postgres con Docker

Si eres usuario de Windows o Mac necesitarás tener instalado Docker Desktop en tu pc o portátil y
éste debe tener cierta capacidad y potencia. Por otro lado, en el caso de que seas usuario de
Windows, deberás tener la versión Professional para poder instalar Docker. Si no es así, visita el
tutorial de [instalación de ubuntu](https://www.arteco-consulting.com/introduccion-ubuntu/), el
mejor sistema operativo para programar totalmente gratis y Open Source. Si eres usuario de Ubuntu o
Debian asegúrate de tener en tu sistema **Docker Compose** también explicado en el tutorial de
instalación de Docker.

## Instalar Postgres con Docker

Para arrancar una base de datos Postgres con docker el proceso no puede ser más sencillo. Basta que
cojamos la plantilla del fichero de configuración de Docker Compose que dejamos a continuación e
invoques al comando que realizará todo el proceso.

```
version: '2'
services:
postgres:
image: 'postgres:latest'
restart: always
volumes:
- './postgres_data:/var/lib/postgresql/data'
environment:
- POSTGRES_PASSWORD=secure_pass_here
ports:
- '5432:5432'
```

Guarda el fichero en local con el nombre **docker-compose.yml** en un directorio denominado
<home*usuario>/docker/postgres si estás en Unix, o <home_usuario>\\docker\\postgres si estás en
Windows. La configuración \*\*guarda los datos en el subdirectorio *./postgres*data*\*\* de forma
permanentemente, puesto que si no, en cada reinicio del contenedor se perderían las bases de datos
alojadas. Luego, posiciónate con un terminal de comandos en el mismo directorio que el fichero y
ejecuta:

```
docker-compose up -d
```

El sistema, primero descargará la imagen de los
[repositorios públicos de Docker](https://hub.docker.com/) al ver que no está disponible localmente
y luego procederá al arranque y a la apertura del puerto indicado en el fichero de configuración. La
opción _\-d_ indica a Docker que se ejecute el servicio en segundo plano.

A partir de ese momento, utiliza tu interfaz gráfico preferido para conectar a la base de datos. Si
no tienes ninguno puedes adquirir el
[cliente gratuito y multi base de datos DBeaver](https://dbeaver.io/).

## Verificar que el servicio PostgreSQL está activo

Para verificar que el servicio está activo y el contenedor ejecutándose de forma normal, pruebe de
ejecutar el siguiente comando de docker que muestra los contenedores en funcionamiento:

```
docker ps
```

Deberá aparecer al menos una entrada correspondiente al contenedor MySQL en estado activo como se
muestra a continuación:

```
CONTAINER ID  IMAGE        COMMAND                  CREATED        STATUS       PORTS                   NAMES
327fd50443a7  postgres:8   "docker-entrypoint.s…"   29 hours ago   Up 6 hours   0.0.0.0:5432->5432/tcp  docker_postgres_1
```

De ser así, puede continuar con el resto de actividades, puesto que como se indica en el fragmento
de texto anterior, el contenedor se encuentra ejecutándose (status up) y escuchando en el
puerto 5432.

## Conectar PostgreSQL con DBeaver

![](/post/037/postgresql_dbeaver_037.png)

Si tenemos el cliente SQL **DBeaver**, una vez arrancado el contenedor, podremos conectarnos con
este cliente multi plataforma ingresando los siguientes datos:

```
Seleccionar nueva conexión para PostgreSQL
Server host: localhost
Port: 5432
User name: postgres
Password: secure_pass_here
```

A continuación darle «Probar conexión» y si todo ha ido bien, «Finalizar». A partir de ese momento
el cliente gráfico SQL podrá abrir una conexión con el contenedor mientras éste esté en ejecución.

Si no tienes mucha experiencia en el manejo de bases de datos como Postgre SQL te recomendamos que
realices una lectura del [tutorial de SQL](https://www.arteco-consulting.com/tutorial-de-sql/) para
principiantes.

## Siguientes pasos

Llegados a este punto, ya estás preparado para desarrollar una aplicación con Java. Visita la página
de
[tutoriales y pasos para programar con Java](https://www.arteco-consulting.com/inicio-rapido-a-la-programacion/)
donde hemos recopilado todos los recursos necesarios para despegar tu carrera profesional como
programador.

Pero antes, conviene que
[crear una nueva base de datos y un usuario limitado con MySQL](https://www.arteco-consulting.com/gestion-de-usuarios-en-mysql/)
o con [PostgreSQL](https://www.arteco-consulting.com/gestion-de-usuarios-en-postgresql/) para no
conectar con el administrador, limitando así las acciones que pueden realizarse desde la aplicación.
Muy interesante sobre todo cuando hay varias bases de datos y aplicaciones conectadas al mismo
gestor, añadiendo una capa de seguridad más que conveniente.


Gracias a DOCKER podemos levantar POSTGRESQL en un CONTENEDOR sin dolores de cabeza, de forma segura y aislada controlando sus recursos

Cómo instalar POSTGRESQL con DOCKER en 5 minutos - //Arteco

Instalar PostgreSQL con Docker


Cuando se crea una aplicación en Java y en cualquier otro lenguaje, no conviene que la aplicación
use las credenciales de administrador del sistema gestor. Para ello, **cada aplicación usa un
usuario propio** que sólo le permitirá el acceso a las tablas que le corresponden. Averigua cómo
crear usuarios en MySQL.

## Qué necesitas para comenzar

Si aun no tienes instalada una base de datos en local, te recomendamos que adquieras una mediante
[el uso de Docker](https://www.arteco-consulting.com/instalacion-de-docker/) que simplifica al
máximo las tareas necesarias, y mantiene tu PC limpio de ficheros esparcidos por tu sistema
operativo.

-   [Instala una base de datos MySQL con Docker](https://www.arteco-consulting.com/instalar-mysql-con-docker/)
-   [Instala una base de datos PostgreSQL con Docker](https://www.arteco-consulting.com/instalar-postgresql-con-docker/)
-   Si quieres ampliar los conocimientos en el uso de base de datos revisa
    [el tutorial de SQL](https://www.arteco-consulting.com/tutorial-de-sql/) que hemos preparado

## Conectar con una base de datos MySQL

Si ha seguido los pasos para la instalación de MySQL con docker necesitará los siguientes parámetros
para conectar al contenedor de base de datos, asegúrese que el servicio está activo.

-   Dirección del servidor (host): _localhost_
-   Puerto del servicio (port): _3306_
-   Nombre de usuario (username): _root_
-   Clave de usuario (password): _secure_pass_here_

Con estos datos está en disposición de conectar a la base de datos. Ésta, puede estar en su
ordenador local mediante Docker, o ser un servidor en red al que conectar remotamente. Sea cual sea
el caso, podrá conectar usando diferentes clientes.

Para conectar con la herramienta nativa de MySQL, en el caso de tenerlas instaladas, podrá hacerlo
usando la siguiente instrucción por el terminal de comandos:

```
mysql -h localhost -P 3306 --protocol=tcp -u root -p
```

O mejor aún, usando algún interfaz gráfico como
[MySQL Workbench](https://www.mysql.com/products/workbench/) o mediante el recomendado y
[cliente multi base de datos DBeaver](https://dbeaver.io/)

En cualquiera de ellos puede agregar una nueva conexión e indicar los datos citados en el listado
anterior.

## Crear usuario MySQL

La creación de un usuario, diferente al administrador de sistemas (root), es un paso importante, ya
que si cometemos un error ejecutando sentencias SQL o si la aplicación hace lo que no esperamos, no
se vea afectado más allá del alcance que pueda tener este usuario. Para ello se suele crear siempre
un usuario por cada base de datos que almacena el sistema gestor MySQL. Así todas las aplicaciones
podrán funcionar de forma aislada sin interferir unas con otras. Esta manera de actuar es la más
recomendada.

Para crear un usuario en MySQL necesitamos saber el nombre de usuario, la contraseña y la ip desde
la que estará permitido su acceso (o si se debe dejar abierto desde cualquier dirección). Una vez
tengamos claros estos parámetros, abriremos una conexión desde la forma que más nos guste y
ejecutaremos la siguiente sentencia:

```
create user 'pepito'@'%' identified by 'pepitoPass';
```

El carácter ‘%’ indica que el usuario ‘pepito’ se podrá conectar desde cualquier IP, de no ser así
se debe sustituir el porcentaje por la IP correspondiente, manteniendo las comillas o haber usado
como host ‘localhost’ permitiendo únicamente las conexiones locales.

## Cambiar contraseña en MySQL

Para cambiar la clave de un usuario en MySQL necesitamos saber a qué usuario debemos referirnos y
desde dónde se va a conectar, o desde dónde está permitido que conecte, la tupla de usuario@host es
necesario para identificar la línea que se desea modificar.

```
ALTER USER 'pepito'@'%' IDENTIFIED BY 'securePepitoPass';
```

Esta sentencia, supone que el usuario tenía previamente acceso desde cualquier dirección de
internet.

## Borrar un usuario en MySQL

Para borrar un usuario, de nuevo necesitamos la pareja usuario y host. La operación no se puede
deshacer, en todo caso, si nos hemos equivocado podremos crear de nuevo el mismo usuario. De hacerlo
así ni la base de datos ni los permisos que tuviera se verían afectados.

```
drop user 'pepito'@'%';
```

## Crear base de datos MySQL

La creación de una base de datos en MySQL es una de las operaciones más sencillas de realizar, sólo
requiere el nombre de la base de datos:

```
create database pepito_app;
```

## Dar permisos a un usuario en MySQL

Una vez creado el usuario y la base de datos dentro del contenedor que ejecuta el sistema gestor SQL
el siguiente paso es otorgar permisos al usuario sobre dicha base de datos. Hay toda una gama amplia
de permisos que pueden tener los usuarios, para afinar con mucha precisión qué puede hacer cada uno
de ellos y que estará prohibido. Esta granularidad ofrece mucho control y seguridad sobre los datos
que se almacenan. Por ejemplo, algunos de los permisos que se usan con frecuencia son:

-   **ALL**, otorga todos los permisos sobre la base de datos
-   **ALTER**, permite modificar tablas, secuencias, etc…
-   **CREATE**, permite crear tablas, secuencias, etc…
-   **DROP**, permite borrar tablas, secuencias, etc…
-   **DELETE**, permite borrar registros en tablas
-   **INSERT**, permite insertar registros tablas
-   **UPDATE**, permite actualizar registros en tablas
-   **SELECT**, permite consultar tablas, secuencias, etc…

En la mayoría de las ocasiones, si tenemos un usuario por base de datos, será suficiente con dar el
permiso ALL, o como mínimo los necesarios para manejar los registros de la base de datos. Sea como
fuere, para dar permisos a un usuario sobre una base de datos deberíamos escribir la siguiente
sentencia SQL:

```
grant all privileges on pepito_app.\* to 'pepito'@'%';
flush privileges;
```

Estas dos sentencias primero asignan **todos los permisos sobre todos los objetos** (.\*) de la base
de datos pepito_app y luego actualizan las cachés de MySQL para que vuelva a recargar la
configuración de los permisos. Éstos se cachean para aumentar la velocidad con la que se resuelven
los accesos sin tener que leer cada vez las tablas de configuración.

## Revocar permisos a un usuario en MySQL

La eliminación de permisos sobre un usuario se hace de forma análoga a la dotación de acceso, pero
en este caso se usa la palabra clave **revoke** de la siguiente manera:

```
revoke insert on pepito_app.\* from 'pepito'@'%';
```

Recuérdese que después de cada cambio de privilegios se debe actualizar la caché con:

```
flush privileges;
```

## Borrar base de datos en MySQL

Si la creación es una de las operaciones más sencillas de realizar, el borrado será similar:

```
drop database pepito_app;
```

Todas las tablas, secuencias, índices y datos de la base de datos se eliminarán de forma permanente
e irrevocable del sistema gestor. ¡Asegúrate de que introduces el nombre correcto de la base de
datos!


Guía con las SENTENCIAS SQL necesarias para crear usuarios y bases de datos en MySQL con los PERMISOS correctos para mantener la seguridad

Cómo crear BASES de DATOS y usuarios en MySQL - //Arteco

Gestión de usuarios en MySQL


Cuando se crea una aplicación en Java y en cualquier otro lenguaje, no conviene que la aplicación
use las credenciales de administrador del sistema gestor. Para ello, **cada aplicación usa un
usuario propio** que sólo le permitirá el acceso a las tablas que le corresponden. Averigua cómo
crear usuarios en PostgreSQL.

## Qué necesitas para comenzar

Si aun no tienes instalada una base de datos en local, te recomendamos que adquieras una mediante
[el uso de Docker](https://www.arteco-consulting.com/instalacion-de-docker/) que simplifica al
máximo las tareas necesarias, y mantiene tu PC limpio de ficheros esparcidos por tu sistema
operativo.

-   [Instala una base de datos MySQL con Docker](https://www.arteco-consulting.com/instalar-mysql-con-docker/)
-   [Instala una base de datos PostgreSQL con Docker](https://www.arteco-consulting.com/instalar-postgresql-con-docker/)
-   Si quieres ampliar los conocimientos en el uso de base de datos revisa
    [el tutorial de SQL](https://www.arteco-consulting.com/tutorial-de-sql/) que hemos preparado

## Conectar con una base de datos PostgreSQL

Si ha seguido los pasos para la instalación de PostgreSQL con docker necesitará los siguientes
parámetros para conectar al contenedor de base de datos, asegúrese que el servicio está activo.

-   Dirección del servidor (host): _localhost_
-   Puerto del servicio (port): _5432_
-   Nombre de usuario (username): _postgres_
-   Clave de usuario (password): _secure_pass_here_

Con estos datos está en disposición de conectar a la base de datos. Ésta, puede estar en su
ordenador local mediante Docker, o ser un servidor en red al que conectar remotamente. Sea cual sea
el caso, podrá conectar usando diferentes clientes.

Para conectar con la herramienta nativa de PostgreSQL, en el caso de tenerlas instaladas (paquete de
ubuntu postgresql-client), podrá hacerlo usando la siguiente instrucción por el terminal de
comandos:

```
psql -h localhost -p 5432 -U postgres
```

O mejor aún, usando algún interfaz gráfico como el recomendado y
[cliente multi base de datos DBeaver](https://dbeaver.io/)

En cualquiera de ellos puede agregar una nueva conexión e indicar los datos citados en el listado
anterior.

## Crear usuario PostgreSQL

La creación de un usuario, diferente al administrador de sistemas (postgres), es un paso importante,
ya que si cometemos un error ejecutando sentencias SQL o si la aplicación hace lo que no esperamos,
no se vea afectado más allá del alcance que pueda tener este usuario. Para ello se suele crear
siempre un usuario por cada base de datos que almacena el sistema gestor PostgreSQL. Así todas las
aplicaciones podrán funcionar de forma aislada sin interferir unas con otras. Esta manera de actuar
es la más recomendada.

Para crear un usuario en PostgreSQL necesitamos saber el nombre de usuario, la contraseña y la IP
desde la que estará permitido su acceso (o si se debe dejar abierto desde cualquier dirección). Una
vez tengamos claros estos parámetros, abriremos una conexión desde la forma que más nos guste y
ejecutaremos la siguiente sentencia:

```
create user pepito with encrypted password 'pepitoPass';
```

Debe cambiarse el nombre de usuario y clave por los correspondientes en cada caso.

## Cambiar contraseña en PostgreSQL

Para cambiar la clave de un usuario en PostgreSQL:

```
ALTER USER pepito WITH PASSWORD 'securePepitoPass';
```

## Borrar un usuario en PostgreSQL

Borrar un usuario no se puede deshacer, en todo caso, si nos hemos equivocado podremos crear de
nuevo el mismo usuario. De hacerlo así ni la base de datos ni los permisos que tuviera se verían
afectados.

```
drop user pepito;
```

## Crear base de datos PostgreSQL

La creación de una base de datos en PostgreSQL es una de las operaciones más sencillas de realizar,
sólo requiere el nombre de la base de datos:

```
create database pepito_app;
```

## Dar permisos a un usuario en PostgreSQL

Una vez creado el usuario y la base de datos dentro del contenedor que ejecuta el sistema gestor SQL
el siguiente paso es otorgar permisos al usuario sobre dicha base de datos. Hay toda una gama amplia
de permisos que pueden tener los usuarios, para afinar con mucha precisión qué puede hacer cada uno
de ellos y que estará prohibido. Esta granularidad ofrece mucho control y seguridad sobre los datos
que se almacenan. Por ejemplo, algunos de los permisos que se usan con frecuencia son:

-   **ALL**, otorga todos los permisos sobre la base de datos
-   **ALTER**, permite modificar tablas, secuencias, etc…
-   **CREATE**, permite crear tablas, secuencias, etc…
-   **DROP**, permite borrar tablas, secuencias, etc…
-   **DELETE**, permite borrar registros en tablas
-   **INSERT**, permite insertar registros tablas
-   **UPDATE**, permite actualizar registros en tablas
-   **SELECT**, permite consultar tablas, secuencias, etc…

En la mayoría de las ocasiones, si tenemos un usuario por base de datos, será suficiente con dar el
permiso ALL, o como mínimo los necesarios para manejar los registros de la base de datos. Sea como
fuere, para dar permisos a un usuario sobre una base de datos deberíamos escribir la siguiente
sentencia SQL:

```
grant all privileges on database pepito_app to pepito;
```

Esta sentencia asigna **todos los permisos sobre todos los objetos** de la base de datos pepito_app.
A partir de ese momento el usuario podrá crear, modificar o borrar objetos como tablas, secuencias,
etc.. Y también operar con las tablas y los registros que contienen pudiendo insertar, actualizar,
consultar y borrar las filas que contienen.

## Revocar permisos a un usuario en PostgreSQL

La eliminación de permisos sobre un usuario se hace de forma análoga a la dotación de acceso, pero
en este caso se usa la palabra clave **revoke** de la siguiente manera:

```
revoke all privileges on database pepito_app from pepito;
```

## Borrar base de datos en PostgreSQL

Si la creación es una de las operaciones más sencillas de realizar, el borrado será similar:

```
drop database pepito_app;
```

Todas las tablas, secuencias, índices y datos de la base de datos se eliminarán de forma permanente
e irrevocable del sistema gestor. ¡Asegúrate de que introduces el nombre correcto de la base de
datos!


Guía de SENTENCIAS SQL necesarias para crear usuarios y bases de datos en PostgreSQL con los PERMISOS correctos para mantener la seguridad

Cómo crear BASES de DATOS y usuarios en PostgreSQL - //Arteco

Gestión de usuarios en PostgreSQL

Las metodologías de DESARROLLO de software en cascada se basan en cerrar una fase antes de pasar a la siguiente, útil para hacer PRESUPUESTOS

INTRO a la metodología en cascada MÉTRICA V3 - //Arteco

Introducción a MÉTRICA V3


La mayoría de compañías que desarrollan su propio software con SCRUM para tener una ventaja
competitiva respecto a la competencia, aplicando **ciclos rápidos de entregas** de nuevas versiones
con el objetivo de diferenciarse y validar nuevos servicios o funcionalidades.

## Por qué nace la metodología SCRUM

En el desarrollo de software tradicional, el proceso para comenzar a elaborar un nuevo sistema de
información se basaba en metodologías muy rígidas con una aproximación en cascada. En este tipo de
aproximaciones se exige que la fase actual se considere estable y validada por los usuarios clave en
ese momento, antes de poder pasar a la siguiente. En muchas ocasiones se requiere la firma de los
responsables indicando que están de acuerdo a lo especificado y por tanto asumen la responsabilidad
de los contenidos generados en esa fase.

Esta aproximación puede ser útil porque requiere realizar muchas validaciones y certificaciones que
garantizan el correcto avance del proyecto. Pero también produce un incremento considerable en los
tiempos necesarios para elaborar cualquier aplicación. Y en el mundo de la empresa, donde se
pretende ser ágil e innovador, el principio de **desarrollo por cascada resulta ser poco ágil**.

## Qué es el desarrollo mediante SCRUM

Para evitar este problema surgieron las metodologías ágiles en donde se busca un mecanismo de
elaborar aplicaciones mucho más dinámico **con entregas periódicas denominados springs** aplicando
cambios incrementales en el software. Entre ellas la más famosa es SCRUM.

SCRUM define unas reglas de metodología ágil, pero dejando la puerta abierta a que las empresas
puedan adaptar la norma general a sus necesidades, puesto que no todas las aplicaciones son iguales
y tienen los mismos requisitos funcionales o técnicos.

## Cómo se organizan las tareas en SCRUM

De manera resumida se puede decir que SCRUM se basa en planificar grupos de tareas, que se tratarán
de resolver en entregables quincenales. Con el despliegue de cada nueva versión se implica al
usuario para que revise los cambios realizados y pueda evaluar el avance del proyecto, pudiendo
tomar decisiones que afecten al grupo de tareas ya planificadas, como cambiar las prioridades,
desestimar algunas o introducir de nuevas.

En SCRUM el equipo de desarrolladores van asignándose tareas registradas, a veces con ayuda de un
coordinador denominado **Scrum Master**, que tratarán de resolver dentro de un entregable. Aunque
puede pasar, que la tarea sea tan compleja que requiera más de un spring. Si es así, debe estudiarse
la posible descomposición de ésta en otras más pequeñas.

Para que los programadores puedan implementar algunas de las tareas planificadas, el equipo de SCRUM
tras cada spring, se reúnen y revisan del conjunto de todas las tareas, denominado **task pool**,
cuáles entrarán en el siguiente spring. Para ello se asigna una puntuación de complejidad por tarea
como mecanismo de estimación de esfuerzo. Es bastante habitual asignar números de la serie de
fibonacci en un intento de hacer una escala que crece rápidamente en complejidad, para evitar el uso
de sistemas muy sofisticados de puntuación, puesto que en la mayoría de las veces sólo se usarán
entre 3 y 5 puntuaciones diferentes.

Tanto los usuarios finales, como cualquier miembro del equipo puede registrar nuevas peticiones
dentro del pool. En cada spring, el equipo revisará de manera consensuada qué tareas deben pasar a
ejecución, respetando en la manera de lo posible la decisión de o de los usuarios.

## Cómo se realizan las comunicaciones en SCRUM

A parte de las reuniones de springs, SCRUM establece de forma general que al principio de cada
jornada y por tanto cada día, el equipo que interviene en el proyecto debe reunirse en una sesiones
denominadas **daily**. En donde **todos los miembros de pié** hablan durante aproximadamente dos
minutos de que tratarán de resolver ese día, qué problemas han tenido en la jornada anterior o qué
limitaciones tienen a la hora de solventar alguna tarea. La consideración de que la reunión se
realice sin ningún miembro sentado es precisamente para darle una calidad de ágil y rápida. Si
alguno de los puntos es lo suficientemente complejo para ser tratado individualmente, el SCRUM
máster debe tomar las riendas de la reunión para dejar registrado ese incidente y proseguir con el
resto de los temas. Es importante que la reunión diaria se lo más breve posible.

Aun así, la reunión diaria es una extraordinaria herramienta para evitar los bloqueos generados por
dependencias o por problemas técnicos, pudiendo levantar la mano cara a los responsables de los
departamentos para solicitar ayuda o recursos que permitan solventar algún obstáculo en el avance
del proyecto. Así mismo, mantienen a la organización informada del estado del proyecto y de la
dirección que debe seguir.

## Dónde puede aplicarse SCRUM

Realmente SCRUM no es exclusivo del desarrollo de software, aunque hay muchas empresas de tecnología
que lo aplican. De hecho es una metodología de gestión de proyectos que puede aplicarse en muchos
ámbitos, siempre que el cambio de dirección durante la ejecución de un proyecto no represente un
problema grave, como los que podrían ocurrir en construcción o edificación. Su uso está más enfocado
en entornos donde hay equipos de personas entre 3 y 12 miembros y donde el componente de innovación
o investigación puede estar presente sin representar un riesgo grave, ni para el proyecto ni para la
organización.

En entornos donde la innovación o el cambio de requisitos pueda conllevar problemas significativos
será preferible una aproximación tradicional a metodologías en cascada ya que estas permiten
realizar unos cimientos sólidos para pasar a la siguiente fase de elaboración. En esa dirección
Métrica v3,
[la mejor metodología de proyectos cerrados](https://www.arteco-consulting.com/introduccion-a-metrica-v3/),
se aplica más convenientemente.

## Conclusiones en el uso de SCRUM

En definitiva, Scrum encaja perfectamente en proyectos de software que tratan de elaborar modelos
explorativos de aplicaciones en donde las necesidades reales de los usuarios o del mercado no pueden
ser definidas con precisión, o también en sistemas cuya tecnología subyacente requerida aun no está
madura y puede sufrir cambios que afecten a la forma de consumir los servicios que provee. Salvo
estos escenarios, SCRUM **garantiza realizar acciones que tienen impacto directo** sobre los
objetivos que se persiguen y una revisión casi constante de adecuación en el avance, evitando
sobre-costes.

Además, gracias a las comunicaciones diarias, se mantiene informado a todos los miembros que tienen
alguna responsabilidad en el proyecto y adicionalmente con las entregas quincenales se consigue
reducir al máximo los posibles desvíos en el software final, o incluso los riesgos en la realización
de costosas inversiones en herramientas que no alcanzan su objetivo cara al usuario final.


SCRUM es la metodología ágil más utilizada para el DESARROLLO de software. Su principio: hacer ENTREGAS RÁPIDAS quincenales. ¿Cómo se hace?

INTRO a la METODOLOGIA de Desarrollo Ágil SCRUM - //Arteco

Introducción a SCRUM


El desarrollo de software programando con TDD se ha convertido en una de las competencias más
deseadas en las empresas. **Ofrece garantías de funcionamiento**, protege de fallos ante evoluciones
y valida la correcta aplicación de los componentes. Averigua por qué conviene usar TDD.

## Qué es el TDD

TDD son las siglas de **Test Driven Development** o desarrollo orientado a test y corresponde con
una manera de abordar los desarrollos de aplicaciones móviles o la programación en general de
sistemas de información. Se conoce como una metodología de desarrollo y se basa en definir casos de
usuario usando el mismo lenguaje de programación, y que por tanto pueden ser ejecutados de forma
automática, para comprobar que la aplicación (aun no programada) da soporte a todos y cada uno de
los requisitos de usuario registrados. La correcta ejecución de todos los casos de usuario,
determina la adecuación de la solución implementada.

Por tanto, puede decirse que aplicar TDD se separa en dos fases bien diferenciadas. La primera de
ellas es recopilar todas las funcionalidades que se espera del sistema de información en forma de
varios (muchos) test unitarios. Mientras que la segunda, trata de implementar (programar) el cuerpo
de la aplicación para que todos los test se ejecuten correctamente. Para llevar a cabo la segunda
fase se deberán programar todos los elementos que finalmente compondrán la aplicación en sí misma.

## Beneficios de usar TDD en un proyecto de software

La programación orientada a test cubre dos aspectos importantes en el desarrollo de software.
Permite delimitar el alcance de un proyecto, ya que todos los requisitos de usuario deberían estar
reflejados en casos de test. En muchas ocasiones, la enumeración de los test se considera parte del
contrato que el proveedor de los servicios de programación deberá llevar a cabo. Y al mismo tiempo,
será el justificante de entrega de un proyecto funcionando correctamente por parte del proveedor.

**La ejecución correcta de los casos valida la implementación** y por tanto el trabajo realizado,
así como también ofrece garantías del correcto funcionamiento ante evoluciones y la subsanación de
errores.

## Cómo implementar la metodología TDD

Prácticamente todos los lenguajes de programación modernos, juntamente con los frameworks de
programación que les acompañan proporcionan funcionalidades, ya sea nativamente o mediante librerías
de terceros, para poder ejecutar test unitarios automáticamente durante la fase de construcción del
programa. Si alguno de los test falla, el binario final no se construye, mostrando al usuario qué
test no superaron la prueba, ya sea porque ocurrió un error o porque retornaron un resultado
incorrecto.

Se debe tener presente que para **aplicar TDD se requiere un estilo de programación muy concreto**,
en donde los programadores realicen unidades funcionales fáciles de invocar por parte de un test.
Esto requiere que el programa tenga **un buen diseño de componentes** y haga una buena gestión de
dependencias entre éstos. Ya que un test debe tener un acceso directo y simple a la invocación de
una unidad funcional cualquiera, sin tener que instanciar cientos de componentes para poder consumir
un método determinado. Así que es **básico realizar una buena descomposición de componentes y
separación de responsabilidades**.

Sin embargo, los programadores juniors suelen carecer de la visión general y la experiencia
necesaria para realizar un buen diseño de componentes que sean fáciles de instanciar y utilizar y
que sólo respondan a una responsabilidad concreta y reutilizable. Es con el tiempo o con ayuda de
otros programadores seniors, que alcanzarán la madurez necesaria para aplicar TDD correctamente. Aun
así conviene introducir TDD en las fases iniciales de todo proyecto de software y guiarles en el
proceso.

En el caso de
[realizar la aplicación con Java](https://www.arteco-consulting.com/por-que-debes-usar-java/), los
test se escriben como clases y métodos. La librería más habitual para ejecutar estas clases en forma
de Test se denomina jUnit, y la herramienta de construcción Maven se encarga de lanzar a ejecución
todas las clases marcadas como test vía jUnit de forma automática.

Los test se consideran código fuente del proyecto, y por tanto debe formar parte del código bajo el
control de versiones. Así que, si los ficheros fuente Java están habitualmente en src/main/java, las
clases de testing estarán en src/test/java.

## Cómo se escribe un test en TDD

La respuesta dependerá del lenguaje de programación. Pero prácticamente todos ellos siguen un mismo
patrón o pseudo código en donde hay unas fases bien diferenciadas por cada caso unitario. Su
implementación puede variar en función del tipo de proyecto donde se intenta implantar TDD. En
proyectos nuevos será mucho más sencillo de introducir, que en aquellos ya existentes y programados
sin tener presente el TDD, por el hecho de que en proyectos nuevos suele ser más fácil realizar una
buena separación de componentes. Aun así, cualquier test debe tener los siguientes pasos.

**Fases de un test unitario**:

1.  **Instanciación** del componente. Los test están destinados a comprobar un caso sobre un
    componente. Conviene mantener a los test especializados en una determinada situación. Es un
    error escribir casos que prueben muchas funcionalidades. Así que en esta fase, el programador
    debe recuperar o crear sólo una instancia del componente o unidad funcional que quiere probar
2.  **Ejecución** del componente. Dado el componente recuperado del paso anterior, lo siguiente es
    invocar la ejecución del mismo, ya sea una función o un método de una clase. Esta invocación se
    debe realizar con unos parámetros conocidos, de tal manera que se sepa de antemano cuál es el
    resultado que deberá ofrecer si el funcionamiento es correcto.
3.  **Comprobación** del resultado. Al realizar la llamada de la unidad funcional conociendo los
    argumentos y suponiéndose que es una funcionalidad determinista (es decir, que ante los mismos
    parámetros, siempre ofrecerá el mismo resultado) se comprueba el resultado obtenido por la
    ejecución de dicha lógica. Si el resultado proporcionado es igual al esperado el test pasa
    correctamente. Si no, se lanza una excepción que avisa del error. Éste, suele provocar la
    finalización del proceso de construcción de la aplicación.

Es importante recalcar que **los test deben comprobar únicamente una funcionalidad**. Deben ser
pequeños y concisos, así que en cualquier proyecto se pueden acumular cientos de test con
normalidad. Los test pequeños y concretos son más fáciles de mantener, de probar y sobreviven con
más frecuencia a los cambios de las aplicaciones.

## Cómo programar con TDD con Spring Boot

Si ya tenemos un proyecto realizado con Spring como el resultante de seguir los pasos que se indican
en
[cómo realizar una aplicación con Spring Boot](https://www.arteco-consulting.com/tu-primera-aplicacion-con-spring-boot/),
incorporar TDD es muy sencillo ya que Spring aporta las dependencias y guías de cómo realizar el
testing para programas de este tipo.

Si el proyecto está hecho con Maven, con Gradle sería de manera similar, basta incluir la
dependencia base que se encarga de agrupar todas las librerías para realizar y ejecutar los test. La
dependencia a incluir en el **pom.xml** es la siguiente:

```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
```

Incluir la versión en la dependencia no es necesario si el proyecto tienen como **parent** el
proyecto de Spring como se indica en el tutorial. En cualquier caso, la inclusión de esta aporta al
proyecto la librería **jUnit** entre otras, necesario para hacer el primer test.

Acto seguido, el programador puede crear un test simple en la ubicación indicada como se muestra a
continuación:

```
// **src/test/java/org/eadp/test/MyTest.java**

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
public class MyTest {

    @Test
    public void myTest() {
        // Fase de inicialización
        MyComponent mc = new MyComponent();

        // Fase de ejecución
        int res = mc.doSomeLogic(1L);

        // Fase de comprobación
        // se espera que el resultado (res) sea igual a 1 (Long)
        Assert.assertEquals(1L,res);
    }
}
```

Spring proporciona un runner que aporta la **instanciación de todo el contexto de Spring** y por
tanto la gestión de dependencias dentro de los test. Así el programador puede inicializar los
componentes requeridos mediante new, o usar la inyección de dependencias mediante @Autowired como un
atributo de la clase MyTest. Si quieres aprender más del uso de Spring y cómo funcionan los
contextos puedes visitar el artículo
[introducción a Spring Boot](https://www.arteco-consulting.com/tu-primera-aplicacion-con-spring-boot/)

El programador deberá crear un gran número de clases y métodos similares a estos para tratar de
cubrir la mayor parte de funcionalidades implementadas. Incluso se debe recurrir a test que prueben
diferentes caminos de la misma lógica, por ejemplo cuando hay un if-else, se añaden dos casos de
test, uno por cada bifurcación del condicional para asegurar que todas las líneas de código son
ejecutadas al menos una vez.

La ejecución del o los test puede hacerse habitualmente directamente desde el editor de programación
que se use. La mayoría de las veces basta con posicionar el cursor encima del test y pulsar el botón
derecho del ratón. En el menú contextual suele aparecer «ejecutar test» o «depurar test». Y si no,
siempre se puede forzar la ejecución mediante la sentencia Maven correspondiente:

```
mvn test
```

La salida de Maven tras ejecutar los tests indica el número de test ejecutados y cuántos tuvieron
una respuesta satisfactória

```
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
```

A partir de aquí, es tarea del equipo de programadores crear todos y cada uno de los casos de test
que se recojan del catálogo de requisitos. Los test deben ser programados en un lenguaje Java de
alto nivel, creando las clases de componentes o servicios necesarios, juntamente con aquellas
destinadas a transportar la información requerida en cada paso. Siempre haciendo una buena
descomposición de componentes según su responsabilidad.

La buena separación en componentes o clases pequeñas y especializadas facilitará su verificación en
test y la reutilización de la lógica escrita entre los diferentes módulos del aplicativo.

## Conclusiones

Aplicar TDD desde un inicio de cualquier proyecto es muy beneficioso tanto en garantías del trabajo
realizado como en la delimitación del alcance del proyecto. Para definirlos se requiere que el
usuario o cliente haga un traspaso del conocimiento que tiene y lo que espera cubrir con el sistema
de información. Es una tarea importante ya que se verá obligado a deshacer las posibles ambigüedades
que aparezcan y sobre todo antes de comenzar a implementar ninguna función.

Si eres usuario de TDD, estaremos encantados de que **compartas con nosotros tus experiencias** ya
sean positivas o negativas y así ampliar más la visión sobre la aplicación de una programación
orientada a test. ¡Déjanos tu opinión!


Desarrollar aplicaciones empresariales con TDD es la mejor manera de garantizar el funcionamiento ante cambios y evolutivos del sistema

INTRO a la METODOLOGIA Test Driven Development (TDD) - //Arteco

Introducción a TDD

DOCKER es un software de VIRTUALIZACIÓN que permite ejecutar aplicaciones enjauladas dentro de unos CONTENEDORES asignándole unos recursos

Qué es DOCKER y por qué usar la VIRTUALIZACIÓN - //Arteco

Tutorial de Docker


Te mostramos los comandos más útiles que utilizarás día a día en el trabajo de proyectos de
desarrollo de software bajo el control de versiones distribuido open source Git. Sincroniza,
compara, mezcla y comparte el código fuente de tus proyectos.

## Qué es Git

Git es **un sistema de control de versiones** para proyectos basados en ficheros. Es un sistema
distribuido, por lo que **cada copia del proyecto contendrá todo el histórico** de cambios. Con él,
se pueden añadir, borrar o modificar archivos de un proyecto de software y compara o recuperar el
estado de los archivos en cualquier momento determinado. Cada paquete de cambios se confirma contra
el repositorio de git, dejándolos registrados como una anotación o commit.

Opcionalmente, se utiliza una copia remota del proyecto bajo el control de git en una ubicación de
Internet, para que uno o más programadores puedan intercambiar las actualizaciones de los ficheros
fuente sin perder el control de las ediciones que se hayan hecho por separado. Hay muchas
plataformas, pero una de ellas muy famosa es [Github](https://github.com/).

## Cómo instalar Git

Git es una herramienta por consola de comandos que se integra bastante bien en los principales
editores de programación existente. Si no lo tienes aún visita la
[guía de instalación de git](https://www.arteco-consulting.com/post/instalar-git-en-win-linux-y-mac).

## Terminología de Git

Git usa unos términos específicos de forma común para referirse a todos los aspectos que le
conciernen, así que si vas a trabajar con git conviene que aprendas todos ellos:

| Término               | Significado                                                                                                                                                                                                                                                                                                                                                 |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **repository**        | se refiere a cualquier copia del proyecto bajo el control y seguimiento de git. Git guarda toda su información en un directorio oculto, dentro del mismo proyecto denominado .git.                                                                                                                                                                          |
| **remote repository** | hace referencia a un repositorio remoto utilizado como mecanismo de sincronización de uno o más programadores. Todos ellos «suben» sus cambios al remoto para dejarlos disponibles al resto de programadores.                                                                                                                                               |
| **commit**            | Anotación. Corresponde a un paquete de cambios que se confirma en el repositorio, de forma local. Típicamente éste contendrá uno o más cambios sobre uno o más ficheros del proyecto y por tanto del código fuente del programa que se está desarrollando. Se considera la unidad básica dentro de la línea de tiempo en cuanto a los cambios se refiere.   |
| **staging**           | Preparación. Es una fase previa en donde se añaden las modificaciones del proyecto a una lista temporal que terminará siendo un commit. Los cambios se podrán descartar o constituirán un commit en el repositorio. Se entiende por cambios las modificaciones, inclusiones de archivos y también las eliminaciones de líneas, palabras o ficheros.         |
| **branch**            | Rama. Git proporciona la posibilidad de tener varias líneas de tiempo en la evolución de un proyecto. Estas ramas representan una evolución potencialmente distinta de los ficheros, pero que en un momento determinado pueden fusionarse. Por ejemplo, para tener en el mismo repositorio la versión 1.x y la 2.x del proyecto.                            |
| **merge**             | Fusionar. Este término se utiliza cuando se desean juntar dos ramas para traspasar las anotaciones (commits) de una rama a otra, muy útil para llevar a la rama «oficial» aquellos cambios «experimentales» en los que se han puesto nuevas funcionalidades o se han arreglado algunos errores.                                                             |
| **conflict**          | La fusión no siempre es automática, si git detecta que un mismo fichero ha sido editado en anotaciones diferentes, a la hora de fusionar todos los cambios, puede pasar que entre en un conflicto porque no sepa con cuál de los cambios de los commits diferente deba quedarse. En este caso se produce un conflicto que debe ser solucionado manualmente. |

Obviamente hay muchos más conceptos técnicos que pueden listarse, pero estos de aquí son los básicos
para poder realizar una operativa básica con git. Veamos cómo se aplican.

## Crear un repositorio vacío

Para crear un repositorio git, ubicados en el directorio raíz de nuestro proyecto, escribiremos:

```
git init
```

Este comando inicializa los índices y referencias internas del repositorio git dentro del directorio
.git. A partir de ese momento podemos realizar las operaciones de añadir ficheros, sincronizarnos
con otros repositorios y demás.

## Crear copia de un repositorio existente

Crear un repositorio vacío puede ser útil a veces, pero normalmente continuaremos el trabajo de uno
ya existente. Para ello se necesita un repositorio remoto, que esté accesible y del cual podamos
bajarnos una copia completa. Por ejemplo si nos ofrecen un remoto en la ubicación
https://host/path/project.git, deberemos usar esta url para hacer una copia:

```
git clone https://host/path/project.git
```

Git mantendrá la referencia del remoto del cual se realizó la copia para poder «subir» los cambios
que hagamos en local o para descargar los cambios que hagan otros programadores del equipo. Al
repositorio remoto le añadirá el nombre de **origin**. Pueden añadirse tantos remotos como se
deseen, y subir o bajar los cambios del remoto que se indique por su nombre. Si no se indica nombre
se utiliza el repositorio origin por defecto.

## Sincronizar con un repositorio remoto

En el siguiente paso, veremos como realizar alguna anotación. Por un momento imagínese que ya hemos
hecho alguna en local y que por el otro lado algún compañero ha realizado otros cambios que ha
subido al remoto. En este supuesto si quisiéramos subir nuestros cambios, primero **git nos obliga a
que nos bajemos los cambios del remoto antes de subir** los nuestros. Así que, cuando intentemos
sincronizarnos con un remoto primero deberemos ejecutar:

```
git fetch
```

Se descarga una fotografía del estado del servidor, en este punto, nuestro repositorio local se da
cuenta de que va un cambio por detrás del remoto. El siguiente paso, traspasar los cambios al
directorio de trabajo en donde se encuentra nuestro proyecto localmente:

```
git pull
```

Este último comando, coge los cambios del remoto que aun no tenemos localmente y los aplica a
nuestros ficheros. Si no hay conflicto, el traspaso de los cambios será transparente y simplemente
percibiremos que los ficheros han sido modificados. Pero si se produce algún conflicto, el fichero
quedará modificado localmente esperando que hagamos una revisión manual sobre este y que terminemos
haciendo una anotación que confirme la fusión.

Siguiendo el supuesto en el que ya habíamos hecho una anotación sobre el repositorio, si ha habido
un conflicto deberemos subir dos commits al remoto, uno por la modificación que habíamos realizado y
otro para resolver el conflicto. De no haber ninguna colisión, sólo subiríamos el commit hecho de
forma local.

Suponiendo que ya hemos solucionado los posibles conflictos, para subir todas las anotaciones
pendientes al remoto deberemos realizar la operación de push

```
git push
```

Esta última operación, subirá todas las anotaciones al servidor, dejándolas disponibles al resto del
equipo.

## Cómo añadir remotos a git

Si hemos partido de un repositorio vació creado con \[git init\] no habrá ningún repositorio remoto
configurado al que subir los cambios. Puede añadirse uno fácilmente ejecutando la siguiente
instrucción:

```
git remote add origin https://host/path/project.git
```

Nótese que al remoto se le ha dado el nombre de \[origin\] por ser el primer y único remoto asignado
al repositorio. Los comandos de fetch, push permiten indicar el remoto sobre el que trabajar.

## Cómo añadir archivos a git

Bien, ya tenemos un repositorio local y sabemos cómo sincronizarlo, pero cómo registramos los
cambios sobre git. Para ello simplemente debemos asegurarnos de si la modificación que hemos
realizado es sobre un fichero que está bajo el control de git, o si es sobre un fichero nuevo, del
cual git aun no conoce nada. Si empezamos con un repositorio vacío, no habrá ningún fichero bajo el
dominio de git, así que el primer paso es añadir el o los archivos al git.

Imaginemos que sobre el repositorio vacío creamos un fichero denominadado index.js, para añadirlo a
git debemos invocar la siguiente opción:

```
git add index.js
```

\[git add\] acepta comodines para no tener que ir añadiendo de uno en uno. Incluso los editores
avanzados de programación realizan este paso automáticamente por nosotros.

En el momento de hacer _add_ el fichero index.js pasa a estar preparado (**staged**) y listo para
viajar en una anotación hacia el histórico de cambios. Si el fichero ya estuviera bajo el control de
git no es necesario invocar la adición.

## Cómo realizar una anotación

En el momento que se tiene uno o más ficheros preparados (staged), ya es posible confirmar los
cambios en el repositorio local mediante una anotación o commit. Todas las anotaciones en git
deberán in acompañadas de un comentario:

```
git commit -m "inclusión del fichero index.js"
```

Esta sentencia registra la evolución del proyecto, y si se trabaja con un remoto podría realizarse
el push. La operación de push podría fallar si alguien hubiera subido algún cambio entre medias, por
lo que estaríamos forzados a realizar primero un _fetch_ y _pull_.

## Cómo descartar cambios de git

Si hemos hechos cambios locales que aun no han sido anotados, podemos descartarlos dejando el
proyecto en el estado de la última anotación. Para ello simplemente debemos ejecutar:

```
git stash
```

Esta operación descarta todos los cambios locales de forma permantente.

## Cómo ver el estado del repositorio

Cuando se han hecho varias modificaciones a lo largo de los ficheros fuente el proyecto es fácil
perder la pista que de líneas se han editado. Para ver todos los ficheros modificados del proyecto
escribiremos:

```
git status
```

Esta operativa nos da una visión general de los recursos cambiados, pero si deseamos ver el detalle
de uno en concreto le pediremos a git que nos muestre las diferencias:

```
git diff index.js
```

Git mostrará un editor de comparación basado en texto algo feote. De nuevo y afortunadamente, los
entornos integrados de programación aportan una interfaz visual mucho más atractiva.

## Cómo ver el histórico de cambios con git

Para mostrar el histórico de cambios sobre todo el proyecto usaremos la opción log:

```
git log
```

Cada commit está identificado con un hash \[c561ae54d2ccb9de92d1512a74ce2ea5b91acf88\], mediante
este identificador podemos ver qué cambios se aplicaron en dicha anotación:

```
git show c561ae54d2ccb9de92d1512a74ce2ea5b91acf88
```

Así no será posible que se nos escape ni una sola coma que pueda producir que nuestro proyecto no se
ejecute correctamente.

## Cómo recuperar el proyecto en una anotación de git

Si deseamos recuperar el proyecto tal y como estaba tras una anotación determinada podemos ejecutar
la operación checkout:

```
git checkout c561ae54d2ccb9de92d1512a74ce2ea5b91acf88
```

Para volver al presente, podemos realizar la siguiente operación que salta en el tiempo hasta la
última anotación disponible:

```
git switch -
```

## Cómo ignorar archivos con git

Hay ficheros que no deben estar en el repositorio de control de código, por ejemplo aquellos que
corresponden con archivos de construcción o autogenerados en el proceso de compilación, como los
.class, .exe, .dll, etc.. Estos se pueden construir cuando sea necesario así que es inútil que se
guarden en el repositorio, salvo que haya un motivo de fuerza mayor.

Para poder indicar a git que se deben descartar algunos ficheros se debe añadir uno (que sí está
bajo el control de git) denominado **.gitignore**. Este es un fichero de texto plano que se aloja en
la raíz del proyecto, en donde se puede indicar ficheros en concreto, patrones o directorios que
fuerzan a git a ignorarlos. Por ejemplo:

```
\*.log
target/
hs_error.log
```

Como se ha dicho, este fichero sí **conviene que esté bajo el control de git** para que todos los
miembros del equipo de desarrolladores ignoren los mismos ficheros, así que no debemos olvidarnos de
añadirlo a la próxima anotación con:

```
git add .gitignore
```

## Cómo crear una rama con git

Como se ha dicho, las ramas representan fotografías distintas del proyecto que pueden evolucionar de
forma independiente. Aunque en la mayoría de los casos termina habiendo un traspaso de anotaciones
de una rama a otra. Los casos más habituales del uso de ramas es la aplicación de **gitflow**.

Gitflow es una manera de organizar las ramas para tener control del proyecto en todas sus fase. De
manera muy resumida diremos que gitflow dice que debe haber la rama con nombre **master** que
represente la versión de la aplicación en producción. Y por otro lado la rama **develop** que
incluye anotaciones adicionales a máster y que corresponden con los evolutivos de la nueva versión a
liberar de la aplicación. Una vez que _develop_ se considera estable, se traspasan las anotaciones
de develop hacia master justo en el momento de publicar y distribuir la nueva versión de la
aplicación. Gitflow recomienda el uso de más ramas, pero con estas es suficiente para escenificar el
uso de git.

De manera automática, la rama master es la rama inicial, y es donde se viajan los commits que se
hacen si no se indica ninguna otra rama. Pero podemos crear una nueva rama a partir de un commit
para hacer evolucionar el proyecto con cambios que son experimentales y puede que se descarten o que
finalmente se apliquen a la versión final del software. Sea cual sea el caso, podemos crear una rama
con:

```
git switch -c develop
```

El argumento _\-c_ indica que si la rama no existe la cree. Ahora pueden hacerse las anotaciones que
se consideren oportunas. Si se trabaja con un remoto, al hacer push de esta rama automáticamente se
creará una igual con el mismo nombre en la ubicación remota. Si deseamos volver a la rama original
pulsaremos:

```
git switch master
```

Esta nueva rama mantiene el mismo histórico que la rama que le da origen, pero los cambios que se
hagan sobre esta no estarán en su predecesora, no al menos hasta que no hagamos una fusión de ramas.

## Cómo fusionar ramas con git

Para fusionar dos ramas, debemos estar posicionados en la rama destino, con _switch_. La operación
lo que realiza es la recuperación de las anotaciones de la rama indicada sobre la actual. Así que si
deseamos traer los cambios de develop a master primero nos posicionamos en master y luego realizamos
la fusión con **merge**

```
git swith master
git merge develop
```

Esta operación puede dar lugar a conflictos, si en master hubiera alguna modificación que no se
hubiera realizado sobre develop. Si es este el caso, deberemos realizar un commit manual con la
resolución del o de los conflictos. Recuérdese que si se trabaja en equipo con un remoto debe
hacerse el _push_ para ofrecer los cambios al resto.

## Cómo borrar ramas con git

Si se ha terminado de usar una rama local y se desea borrar, bastará con decirle a git nuestra
intención de la siguiente forma:

```
git branch -d develop
```

Pero es posible, que deseemos borrar la rama en el repositorio remoto en vez de en local, si es así
la sentencia cambia ligeramente.

```
git push origin --delete develop
```

Debe tener presente que si el resto del equipo se bajaron los cambios de la rama borrada, aunque
haya borrado la rama en el remoto de referencia, ésta seguirá existiendo en las otras copias
repartidas en el equipo.

## Conclusión

Git es una herramienta muy potente para controlar todos los cambios en los archivos que componen un
proyecto, además representa un buen mecanismo para las copias de seguridad y utilidad de
sincronización entre computadoras.

En las anteriores líneas hemos visto los fundamentos básicos de git y cómo utilizarlo desde la
consola de comandos o terminal. Pero afortunadamente los entornos integrados de programación suelen
incorporar las operaciones que hemos visto de forma nativa mediante acciones contextuales o accesos
de la barra de herramientas que simplifican y agilizan el uso de git.

Te recomendamos que eches un vistazo a alguno de los
[IDEs que puedes usar totalmente gratis](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/)
ya que son Open Source y multi plataforma.

Déjanos tus comentarios abajo o [escríbenos](mailto:info@arteco-consulting.com) para compartir tu
experiencia o para mejorar este contenido. Saludos!


Averigua como usar git como un PROFESIONAL y que no se te escape ni una coma durante la PROGRAMACIÓN de tus aplicaciones de software

TUTORIAL de GIT para usar los COMANDOS Importantes - //Arteco

Tutorial de GIT

Structured Query Language, el LENGUAJE más utilizado en el manejo de DATOS seguros a través de su integridad referencial. ¡Averigua cómo!

TUTORIAL para MANIPULAR datos con SQL - //Arteco

Tutorial de SQL


Maven es la **herramienta por excelencia para controlar la construcción y descargar dependencias**
de cualquier aplicación Java. Desde la compilación hasta la construcción del binario final pasando
por los test unitarios. En las siguientes líneas te enseñamos lo que debes saber para convertirte en
un profesional de Maven.

## Qué es Maven

Maven es una herramienta Open Source desarrollada en Java por la asociación Apache Foundation, un
organismo sin ánimo de lucro que publica recursos libres de derechos para asegurar el desarrollo y
la innovación en las tecnologías de la información. El objetivo de esta herramienta es **facilitar y
estandarizar la organización y la construcción de proyectos de software**, principalmente para
proyectos destinados a la máquina virtual de Java.

## Cómo instalar Maven

Puedes consultar el artículo de
[instalación de maven](https://www.arteco-consulting.com/post/instalacion-de-maven/) para obtener un
proceso detallado de cómo proceder para dejarlo bien configurado en tu estación de desarrollo.

## Organización de archivos

![](/post/028/maven-tree.png) ![](/post/028/maven-tree.png)

Maven define que todo proyecto Java, ya sea para construir una librería o para una aplicación, debe
tener la siguiente estructura de directorios en el sistema de ficheros:

-   **pom.xml**: fichero de descripción, ubicado en la raíz del proyecto. En él se indica su nombre,
    la ubicación que tendrá éste en el repositorio de binarios, las dependencias que necesita para
    compilar, para ejecutar o para lanzar los test. También se especifica si se hará uso de
    _plugins_.
-   **src/main/java**: directorio en donde se ubicarán los ficheros Java del proyecto que serán
    compilados y formarán parte del binario resultante. A partir de ese directorio es donde se
    tendrán en cuenta los paquetes de los ficheros Java. Por ejemplo, el fichero fuente de la clase
    _org.proyecto.Persona_ se ubicará en _src/main/java/org/proyecto/Persona.java_.
-   **src/main/resources**: permite añadir recursos que también se incorporarán dentro del binario
    resultante, pero que no deben ser compilados. Por ejemplo, los ficheros con extensión
    _.properties_, XML o imágenes.
-   **src/test/java**: directorio para colocar las fuentes Java que únicamente se usarán en la
    ejecución de los test unitarios. El contenido de este directorio no será empaquetado en el
    binario final.
-   **src/test/resources**: necesario si para la ejecución de los test se utilizan otros recursos
    como ficheros XML o CSV con datos de prueba para verificar los algoritmos. Los ficheros
    incluidos no serán empaquetados en el fichero final.
-   **target/classes**: en este directorio se almacenarán las clases Java resultantes de la
    compilación de las fuentes almacenadas en _src/main/java_.
-   **target/`<proyecto.jar>`**: típicamente los proyectos generarán un binario con el contenido de
    _target/classes_ más _src/main/resources_ en un único archivo empaquetado con extensión _jar_.
    Si el proyecto es una aplicación, éste contendrá además todas las dependencias dentro de él para
    que se disponga de todo lo necesario a la hora de ejecutar la aplicación, formando un fichero
    denominado _fat-jar_.

Prácticamente todos los editores de programación de Java trabajan perfectamente con los proyectos
organizados como indica Maven. Se puede considerar que **se ha convertido en un estándar de facto**.
Los editores automáticamente procesan el fichero _pom.xml_ para tener presente las dependencias
necesarias y ajustar la configuración del proyecto acorde con lo especificado en el fichero.

## Fases de construcción

Una vez definido cómo deben organizarse los ficheros fuente que constituyen un proyecto, el
siguiente paso es invocar a Maven para que pueda realizar el proceso de construcción del proyecto.
Maven tiene presente las dependencias entre módulos que puede haber, así que si se trata de un
proyecto modular, el orden de construcción de los módulos se realizará en el orden correcto que
permita satisfacer las dependencias. La construcción de cada módulo individual se realiza de la
misma manera que se hace sobre un proyecto simple. Por tanto, ya sea para un módulo o para un
proyecto simple, Maven tratará de construir el módulo o proyecto, pasando siempre por las siguientes
fases en el orden que se indica:

1.  **validate**: valida que el proyecto es correcto y que toda la información necesaria está
    disponible según la especificación de los POMs.
2.  **compile**: compila el código fuente del proyecto revisando todos los directorios
    _src/main/java_, alojando los ficheros _.class_ en _target/classes_.
3.  **test**: prueba el código fuente compilado utilizando el marco de prueba unitario indicado en
    el POM, normalmente _JUnit_. En esta fase se lanza la ejecución de todos los test. Si el
    resultado de alguno de ellos no es correcto se interrumpe la construcción.
4.  **package**: recoge el código compilado y lo empaqueta en su formato distribuible, normalmente
    como un fichero del tipo _`<application>`.jar_.
5.  **verify**: ejecuta cualquier comprobación de los resultados de las pruebas de integración para
    garantizar que se cumplan los criterios de calidad.
6.  **install**: instala el paquete en el repositorio local, para usarlo como dependencia en otros
    proyectos locales.
7.  **deploy**: copia el binario construido en el repositorio remoto, para compartirlo con otros
    desarrolladores y proyectos. Esta fase requiere que se indique la URL del repositorio donde
    desplegar, así como también las credenciales a usar en caso necesario.
8.  **clean**: (opcional) Si se invoca manualmente, Maven eliminará todos los recursos generados
    durante la compilación y el empaquetado, borrando el directorio _target_.
9.  **site**: (opcional) produce un informe en HTML acerca del proyecto mostrando la documentación
    del API de Javadoc y estadísticas según las herramientas de análisis que se hayan configurado.

En la mayoría de las veces será suficiente con lanzar la ejecución de Maven parando en algún momento
anterior al _deploy_ si se trabaja localmente. Por ejemplo, en muchas ocasiones bastará con ejecutar
_package_ si es una aplicación simple o _install_ si se trata de la actualización de algún módulo
usado por otra aplicación. Para indicar hasta qué punto se desea ejecutar la construcción de un
proyecto, en la línea de comandos ubicándose el directorio donde está alojado el _pom.xml_, se
invocará a Maven mediante el comando _mvn_ argumentando la fase donde finalizar:

```
    # update target/classes
    mvn compile

    # install binary into local repository
    mvn install

    # both steps
    mvn compile install

    # clean resources before install
    mvn clean install
```

Sea cual sea la fase indicada, si pasa por _package_, Maven dejará disponible el binario localmente
ubicado en el directorio _target_ del proyecto o módulo correspondiente.

## Gestión de dependencias

Uno de los mayores beneficios del uso de Maven es la buena gestión de dependencias que realiza la
herramienta juntamente con el gran catálogo de librerías que ofrece públicamente. Todas ellas sin
ningún coste de uso. Maven **viene configurado de serie con unos repositorios públicos** donde se
despliegan la mayoría de librerías _Open Source_ del ecosistema de Java. Para hacer uso de
cualquiera, bastará con indicar una nueva dependencia en el POM del proyecto.

Cuando el proyecto requiere de una dependencia, Maven irá a buscarlo al repositorio local. Si la
librería no está alojada ahí, normalmente un fichero con extensión _.jar_, tratará de descargarlo de
Internet buscando en los repositorios públicos. Si lo encuentra remotamente, guardará una copia
local para que esté disponible para la siguiente vez. El directorio por defecto del repositorio
local suele estar en **`<home_usuario>`/.m2/repository**. Aunque puede indicarse una ruta
alternativa en el fichero de configuración de Maven **`<home_usuario>`/.m2/settings.xml**. Mientras
no se indique lo contrario, todas las dependencias de todos los proyectos serán almacenadas en ese
directorio. Así que fácilmente pueden acumularse varios Gigas de información a medida que avanza el
uso de diferentes librerías y versiones en el conjunto de los proyectos. El usuario es libre de
eliminar el contenido de éste, provocando que Maven deba descargar de nuevo las dependencias
necesarias.

Las dependencias del proyecto deben ir dentro de la sección de _`<dependencies>`_. Debe tenerse en
cuenta que éstas pueden tener diferentes ámbitos de uso denominados _**scopes**_. El ámbito se
indica en el atributo _`<scope>`_ del XML y permite separar aquellas dependencias que son necesarias
para compilar, de otras que serán sólo requeridas durante la ejecución del aplicativo. Maven soporta
los siguientes _scopes_:

-   **compile**: es el ámbito por defecto en caso de que no se indique ningún otro. Se refiere a las
    dependencias ordinarias que son necesarias tanto para la compilación como para la ejecución. Por
    tanto deberán ir acompañando al binario de la aplicación final.
-   **provided**: son las dependencias que son necesarias para compilación y ejecución al igual que
    en el ámbito _compile_, pero con la diferencia de que no hace falta que se añadan al binario de
    la aplicación. Se considera que estas serán proporcionadas a la aplicación de forma externa a
    Maven. Este ámbito es útil cuando se despliega una aplicación en un servidor de aplicaciones el
    cual ya dispone de las librerías necesarias.
-   **runtime**: hace referencia a aquella que no es necesaria para la compilación, pero sí debe ir
    acompañando al binario de la aplicación final puesto que la ejecución del programa requerirá
    alguna funcionalidad de la librería citada.
-   **test**: reservado para aquellas otras que únicamente son requeridas para realizar las pruebas
    de test unitarios, por lo que no son necesarias ni para la compilación ni para la ejecución. Por
    tanto, no acompañarán al binario final.
-   **system**: a efectos prácticos es similar a compile, con la salvedad de que el fichero JAR es
    proporcionado manualmente por el programador, indicando la ruta del fichero. No será necesario
    que Maven lo resuelva como dependencia usando el repositorio local.
-   **import**: sirve para importar todas las dependencias definidas en otro artefacto de tipo POM.
    Requiere que las dependencias estén citadas en la sección del XML denominada
    _`<dependencyManagement>`_ de este segundo POM.

En la mayoría de las ocasiones sólo será necesario indicar el ámbito de tipo _test_, puesto que el
otro ámbito _compile_ será aplicado por Maven automáticamente en ausencia del dato.
Independientemente del ámbito, todas las dependencias deben ir dentro de la sección
_`<dependencies>`_:

```
<project ...>
    ...
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        ...
    </dependencies>
    ...
</project>
```

La gran variedad de dependencias existentes en Maven hace difícil que el programador pueda recordar
qué datos indicar a la hora de incluir una librería. Además, Java está compuesta por una comunidad
muy activa de programadores que liberan nuevos recursos y actualizaciones con frecuencia. Todo ello
complica la tarea de añadir una librería o artefacto dentro del proyecto. Para facilitar esta tarea
existe una página web que ofrece una interfaz de usuario destinada al programador. En ella el
usuario puede localizar y copiar la dependencia cómodamente en el POM del proyecto. Esta página hace
uso de los mismos repositorios públicos que usa Maven indexando todo su contenido:

-   [https://mvnrepository.com/](https://mvnrepository.com/)

La página web ofrece estadísticas de uso de las principales librerías que pueden ser útiles para
descubrir otros proyectos a tener presente en futuros desarrollos. A medida que los proyectos
crecen, la lista de dependencias también lo hace y por regla de tres, las dependencias transitivas
de las librerías incluidas. En ocasiones puede ocurrir que dos dependencias entren en conflicto al
usar internamente versiones diferentes de una misma librería. Encontrar y resolver esta situación
requiere un trabajo de investigación y de búsquedas por la red no trivial. Una opción que ayuda al
diagnóstico es mediante Maven. Se le puede solicitar que muestre información de cómo ha resuelto las
dependencias directas e indirectas, indicando qué versión de cada una de ellas se está aplicando.

Para ver el resultado de la resolución de los requerimientos debe ejecutarse el siguiente comando:

```
mvn dependency:tree
```

Esta sentencia imprimirá por consola la resolución de dependencias usadas durante la compilación y
el empaquetado de la aplicación. Resulta muy útil a la hora de solucionar alguna incompatibilidad
entre librerías usadas o comportamientos anómalos en tiempo de ejecución.

## Primera aplicación con Maven

La manera más sencilla de realizar una primera aplicación con Maven y Java es invocar al asistente
de Maven para que cree un esqueleto de aplicación. Para ello necesitamos hacerle llegar el grupo, y
el nombre del project (artifactId) al asistente que puede invocarse desde el terminal.

Por ejemplo si queremos crear un proyecto con el grupo: org.eadp y artifact:my-app ejecutaremos el
siguiente comando:

```
mvn archetype:generate \\
    -DarchetypeArtifactId=maven-archetype-quickstart \\
    -DinteractiveMode=false \\
    -DgroupId=org.eadp \\
    -DartifactId=my-app
```

La ejecución de un arquetipo de Maven no es más que la aplicación de una plantilla predeterminada
que genera un esqueleto de aplicación, creando el contenido dentro del directorio con el mismo
nombre que el dado al proyecto a través de la variable artifactId.

![](/post/028/maven-code.png)

El proyecto puede ser importado sin ningún problema desde cualquier editor de programación de Java
con soporte para Maven. Pruebe de realizar la construcción del proyecto con **mvn package** para ver
qué sucede.

El generador crea un test inicial como plantilla para que el programador tenga una referencia rápida
de cómo crear los tests y poder así aplicar una
[metodología de desarrollo basada en tests](https://www.arteco-consulting.com/introduccion-a-tdd/).
Puede lanzar la ejecución de los tests desde el terminal de comandos con **mvn test**

En cualquier caso, le recomendamos que se familiarice con el uso de su
[IDE de Java](https://www.arteco-consulting.com/instalar-editor-integrado-de-java/) preferido que
simplificará enormemente las tareas de construcción, depuración, tests y cualquier otra tarea diaria
del programador.

Déjanos tus comentarios abajo o [escríbenos](mailto:info@arteco-consulting.com) para compartir tu
experiencia o para mejorar este contenido. Saludos!


Con esta guía ENTENDERÁS el funcionamiento y aprenderás a sacarle el máximo partido al SOFTWARE de CONSTRUCCIÓN de proyectos Java más usado

TUTORIAL de MAVEN para exprimir su potencia con JAVA - //Arteco

Tutorial de Maven

Sigue nuestro TUTORIAL paso a paso y aprenderás como realizar un programa en JAVA desde cero, instalando todas las herramientas necesarias

PROGRAMA tu primera Aplicacion con JAVA - //Arteco

Iniciación a Java 


La gestión del tiempo en Java ha sufrido un gran rediseño en la versión 8 de Java y posteriores,
llevándola un paso más allá hacia **un Api bien estructurado y muy potente**. En este artículo
explicamos cómo usarlo y en qué se difiere del api previo a _java.time_.

## Introducción a la gestión de fechas con Java

Actualmente en el Jdk de Java hay dos Apis para la gestión de calendarios, fechas y horas que puede
usar el programador. El primero de ellos es un api obsoleto que será eliminado en un futuro de Java,
y corresponde con el uso de **java.util.Date**, **java.util.Calendar** y relacionados. Estos objetos
están prácticamente desde el inicio de Java y a través de la evolución del lenguaje y su uso en
entornos cada vez más diversos se han quedado desfasados ya que no se tuvieron en cuenta algunos
aspectos en la fase de diseño, como por ejemplo la concurrencia y la inmutabilidad.

Para remediar los puntos negativos, en la versión de Jdk 8 y posteriores, el lenguaje incorpora un
nuevo api para la gestión de tiempo, denominado de forma común por **java.time** por el paquete en
el que están ubicadas las clases que lo conforman. Veremos en las siguientes líneas cómo usar cada
uno.

## Gestión de tiempos y fechas en Jdk 8+

Recuerda que el API de tiempos **sólo está disponible en Java 8 y superiores**. Si trabajas con una
versión anterior conviene que revises la siguiente sección.

El api conocido como **java.time** corresponde a un rediseño por completo, maduro y estable por
parte de la comunidad de mantenedores de Java, en el que se han incluido las mejores técnicas para
el control de tiempo permitiendo que Java pueda ser usado en entornos tan diversos y complejos como
el cálculo de fechas astronómicas con una precisión asombrosa. Además se ha tenido en cuenta la
facilidad, la inmutabilidad y la concurrencia para evitar problemas en el uso o en la ejecución de
aplicaciones complejas.

Los principales objetos de **java.time** para la gestión de horas y fechas son:

-   **Clock** Un reloj que proporciona acceso al instante actual, fecha y hora utilizando una zona
    horaria.
-   **Duration** Una cantidad de tiempo basada en el tiempo, como ’34 .5 segundos ‘.
-   **Instant** Un punto instantáneo en la línea de tiempo.
-   **LocalDate** Una fecha sin zona horaria en el sistema de calendario ISO-8601, como 2007-12-03.
-   **LocalDateTime** Una fecha y hora sin zona horaria en el sistema de calendario ISO-8601, como
    2007-12-03T10: 15: 30.
-   **LocalTime** Hora sin zona horaria en el sistema de calendario ISO-8601, como 10:15:30.
-   **MonthDay** Un mes al día en el sistema de calendario ISO-8601, como –12-03.
-   **OffsetDateTime** Una fecha y hora con una compensación de UTC / Greenwich en el sistema de
    calendario ISO-8601, como 2007-12-03T10: 15: 30 + 01: 00.
-   **OffsetTime** Una hora con una compensación de UTC / Greenwich en el sistema de calendario
    ISO-8601, como 10: 15: 30 + 01: 00.
-   **Period** Una cantidad de tiempo basada en la fecha en el sistema de calendario ISO-8601, como
    ‘2 años, 3 meses y 4 días’.
-   **Year** Un año en el sistema de calendario ISO-8601, como 2007.
-   **YearMonth** Un año-mes en el sistema de calendario ISO-8601, como 2007-12.
-   **ZonedDateTime** Una fecha y hora con una zona horaria en el sistema de calendario ISO-8601,
    como 2007-12-03T10: 15: 30 + 01: 00 Europa / París.
-   **ZoneId** Una identificación de zona horaria, como Europa / París.
-   **ZoneOffset** Un desplazamiento de zona horaria de Greenwich / UTC, como +02: 00.

El uso de cualquiera de ellas es bastante intuitivo puesto que aportan métodos estáticos para
obtener nuevas instancias, y métodos que permiten operar con ellos, siempre generando una nueva
instancia gracias al concepto de inmutabilidad. Veamos algunos ejemplos:

```
import java.time.*;

LocalDate localDate1 = LocalDate.now();
LocalDate localDate2 = LocalDate.of(2020, 02, 20);
LocalDate localDate3 = LocalDate.parse("2020-02-20");

DayOfWeek dow = localDate1.getDayOfWeek();
int dom = localDate1.getDayOfMonth();

LocalDate localDate4 = localDate1.plusDays(3);
...
```

Los métodos de consulta y operación están fuertemente unificados entre los diferentes objetos del
paquete, así que será tremendamente fácil incorporar y operar con cualquiera de ellos. Realizar
tareas que con el api obsoleto resultaban arduas, con el nuevo se reducen a algunas pocas líneas,
ganando en confianza y reduciendo errores.

Por último, el nuevo Api incorpora un nuevo formatter, esta vez sí reutilizable y thread-safe que
permite re aprovechar la instancia para diferentes construcciones o formateos en paralelo. Éste
nuevo formatter está ubicado en la clase
[java.time.format.DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
y su construcción sigue la regla de los métodos estáticos:

```
import java.time.*;
import java.time.format.*;

DateTimeFormatter formatter = DateTimeFormatter.of("yyyy-MM-dd");

// de String a LocalDate
LocalDate ld = LocalDate.parse("2020-04-03", formatter);

// de LocalDate a String
String ld_str = ld.format(formatter);
```

Los ejemplos puestos aquí son equivalentes para los objetos como ZoneDateTime, con la salvedad de
que para aquellos que conlleven la información de la Zona (latitud) a la que pertenecen será
necesario aportar un id de zona u offset para que Java pueda construir una instancia correctamente.

## Fechas y horas Jdk pre 8

Recuerda que **este es un API obsoleto** y que será eliminado. Sólo deberías usar este si debes
mantener alguna aplicación existente en el que sea impracticable el cambio del API viejo por el
nuevo.

La gestión de tiempo en Jdk pre 8 consiste principalmente en el uso del objeto java.util.Date. Éste
se basa en el almacenamiento y gestión de un determinado instante en base a los **milisegundos
transcurridos desde 1970**. Por tanto, cuando se crea una fecha según la hora del sistema, o cuando
se realiza de forma manual indicando día, mes, año y hora, éste convierte el conjunto de estos
números a milisegundos. Por tanto, puede deducirse que será un problema la suma de fechas u horas
que estén asociadas a diferentes latitudes.

Otro de los problemas es que estos objetos **no son inmutables**, por lo que puede haber referencias
a la misma instancia desde diferentes puntos de la aplicación. Si uno de ellos modifica una fecha,
para el otro consumidor la fecha también se habrá modificado. Este comportamiento no es deseable,
sobre todo en entornos concurrentes con varios hilos en ejecución ya que da problemas en la
depuración y corrección de errores.

En cualquier caso, siendo conscientes de las limitaciones que tiene, el **uso de java.util.Date está
muy extendido** en muchas aplicaciones por el amplio tiempo que ha estado desplegado este api en las
diferentes versiones hasta que apareció Java 8. Por este motivo puede ser necesario tener que usar
alguna de estas clases, veamos algunos ejemplos:

```
import java.util.Date;
import java.text.SimpleDateFormat;
...

// fecha del sistema con hora, minutos y segundos
Date fecha1 = new Date();

// fecha manual
Date fecha2 = new Date(2020,01,01,12,0,0);

// convertir fecha a string
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
String fecha1_str = sdf.format(fecha1);

// convertir string a fecha
Date fecha3 = sdf.parse("31/12/2020");
```

Mediante el objeto Date podemos manipular la fecha almacenada, como cambiar los minutos o los
segundos. Por otro lado la clase **java.text.SimpleDateFormat** permite establecer un patrón en base
al uso de uno símbolos específicos para las fechas con el que convertir de o hacia una cadena de
caracteres. El patrón usado indica:

-   **dd** dos cifras para el día del mes
-   **MM** dos cifras para el número de mes.  
    Ojo usar mayúsculas, minúsculas se refiere a minutos.
-   **yyyy** cuatro cifras para el número de año

Hay muchos
[más símbolos para fechas y horas](https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html)
que se pueden usar, sobre todo para horas, minutos, zonas horarias, horario de verano, etc….
Conviene revisarlos porque los símbolos se mantienen en el nuevo api de fechas.

Aunque el objeto Date es mutable, para alterar una fecha se recomienda pasar por otra clase que hace
una gestión más completa en el ajustes de horas y tiempo, por ejemplo para tener presente el horario
de verano o invierno. Esta se llama **java.util.Calendar** y su extensión correspondiente al
calendario común más usado **java.util.GregorianCalendar**. Es preferible hacer modificaciones de
fechas usando estos para evitar posibles problemas por el uso puro de los milisegundos que almacena
Date. Veamos unos ejemplos:

```
import java.text.SimpleDateFormat;
import java.util.Calendar;
...

Date date = new Date();

Calendar calendar = Calendar.getInstance();
calendar.setTime(date);

// sumar tres meses
calendar.add(Calendar.MONTH, 3);

// añadir 25 horas
calendar.roll(Calendar.HOUR, 25);

Date dateMod = calendar.getTime();
```

Como puede verse en el ejemplo dado un Date, se consigue otro objeto del mismo tipo habiéndolo
modificado mediante el uso intermedio del Calendar. Éste tiene varios métodos con los que poder
operar con la fecha almacenada en su interior, dejamos la
[referencia al api de Calendar](https://docs.oracle.com/javase/7/docs/api/java/util/Calendar.html)
para más información.

## Convertir LocalDates a Dates y viceversa

Cuando se diseñó el Api de Java 8 ya se planteó la opción de que las aplicaciones pudieran convivir
usando ambos Apis, así que modificaron ligeramente los objetos de ambas bandas para poder hacer la
conversión de unos a otros. Estos métodos desaparecerán cuando el Api obsoleto sea retirado del Jdk.

Normalmente, para convertir objetos de un api al otro se requiere pasar por una instancia de
**Instant** como se indica en los siguientes ejemplos:

**Convertir LocalDate to Date**:

```
ZoneId defaultZoneId = ZoneId.systemDefault();
LocalDate localDate = LocalDate.of(2016, 8, 19);
Date date = Date
    .from(localDate.atStartOfDay(defaultZoneId).toInstant());
```

**Convertir Date to LocalDate**:

```
Date date = new Date();
ZoneId defaultZoneId = ZoneId.systemDefault();
Instant instant = date.toInstant();
LocalDate localDate = instant
    .atZone(defaultZoneId).toLocalDate();
```

Obviamente con ZonedDateTime el proceso será algo más sencillo, puesto que éste ya contiene
información de la zona horaria sin que sea necesario hacérsela llegar de nuevo.

## Conclusiones

Como puede observarse las operaciones básicas sobre tiempos y fechas en Java son bastante sencillas
usando el api incorporado en el JDK 8 y que se ha mantenido en las siguientes versiones. Es la
manera conveniente de gestionar este tipo de información en cualquier desarrollo y programa con Java
que estés realizando o manteniendo. Se recomienda, siempre que sea posible, sustituir los usos de
Date por LocalDate o LocalDateTime según corresponda, o incluso mediante ZoneDateTime si mantienes o
desarrollas una aplicación global.


A partir de JAVA 8+ se introdujo en el JDK unas nuevas clases y métodos para la GESTIÓN DE TIEMPOS y FECHAS. Aquí enumeramos las principales

Cómo usar FECHAS y TIEMPO correctamente en JAVA 8+ - //Arteco

Introducción a Java.time


Las expresiones regulares son un gran aliado a la hora de buscar y reemplazar contenido textual que
simplifica enormemente la búsqueda y sustitución de términos variables.

## Qué son las expresiones regulares

Las expresiones regulares o simplemente regex son un gran aliado a la hora de buscar y reemplazar
contenido textual. Puede decirse que son el gran subestimado en la edición de texto, puesto que aun
ofreciendo una capacidad enorme a la hora de buscar situaciones variables, pocos programadores las
utilizan por la complejidad de definir estas expresiones. Sin embargo, su uso es mucho más fácil de
lo que parece, sobre todo si se compara con el tiempo que se requiere escribir un analizador léxico
o una gramática como podría hacerse con ANTLR, por ejemplo. Además, si el programador se familiariza
con éstas, podrá hacer uso de toda una batería de comandos del sistema operativo que permiten buscar
y reemplazar contenido con ellas. La forma en la que se escriben las expresiones regulares es
prácticamente un estándar, así que el usuario podrá usarlas en muchos ámbitos distintos.

## API de Java para las expresiones regulares

En las siguientes líneas se describe cómo escribir y ejecutar expresiones regulares aprovechando el
API de Java para poder realizar procesos sobre entradas de datos, reglas de validación, o _parsers_
específicos que frecuentemente se dan en las tareas ordinarias del programador.

El API de Java para expresiones regulares está incluido de base en el JDK y por tanto en el JRE sin
que deba añadir ninguna dependencia adicional. Su punto de partida es la construcción de un objeto
**Pattern** del paquete _java.util.regex_. _Pattern_ tiene un método estático _compile(«…»)_ por el
cual se obtiene una instancia, dado un _String_ que contiene la expresión regular. Este objeto debe
reutilizarse entre usos de la misma expresión regular, para evitar incurrir en tiempos innecesarios
al compilar una y otra vez la misma expresión.

Así que una vez compilada, el siguiente paso es aplicar la expresión sobre una entrada de texto a
través del método del objeto _matcher(«…»)_. Este método devuelve un objeto _Matcher_ que agrupa
todos los resultados que haya podido producir la aplicación de la expresión regular (_regex_) sobre
la entrada. Obviamente este objeto no podrá reutilizarse para entradas de datos diferentes. El
primer y más importante resultado que ofrece _Matcher_ es si la _regex_ ha sido válida o no para la
entrada, esto es ofrecido por el método _boolean find()_. Si la respuesta es cierta, mediante el
método _group(int)_, el programador puede obtener el extracto de la entrada que ha sido compatible
con cada uno de los grupos definidos en la expresión regular. El primer grupo es el 1, el segundo el
2, etc…

Véase como encajan todas las piezas del API de Java, y posteriormente se describirá como definir
complejas _regexps_. Imagínese un caso sencillo en donde se desea comprobar si una entrada contiene
la palabra _hola_, al igual que se realizaría con un _String.contains()_.

```
Pattern pat = Pattern.compile("hola");
String input = "la caracola dice hola a la paloma";
Matcher mat = pat.matcher(input);
if (mat.find()) {
    System.out.println("regex encontrada");
} else {
    System.err.println("regex NO encontrada");
}
```

La anterior expresión regular _hola_ permite buscar la palabra dentro del contenido alojado en la
variable _input_. Esta expresión es muy simple ya que no aporta nada variable, sólo un literal.

Sin embargo, supóngase que se desea escribir otra expresión que permita obtener el nombre de los
sujetos de la entrada para saber quién saluda a quién. En este caso se necesita que la expresión
acepte entradas variables y además extraiga quiénes son los actores que intervienen en el saludo. El
siguiente fragmento escribe una _regex_ que permite precisamente eso, añadir dos partes variables a
la expresión y definir dos grupos para obtener los sujetos.

```
String regex = "la (\\w+) dice hola a la (\\w+)";
Pattern pat = Pattern.compile(regex);
String input = "la caracola dice hola a la paloma";
Matcher mat = pat.matcher(input);
if (mat.find()) {
    System.out.println("regex encontrada");
    System.out.println("Sujeto activo :"+mat.group(1));
    System.out.println("Sujeto pasivo :"+mat.group(2));
} else {
    System.err.println("regex NO encontrada");
}
```

Esta nueva expresión es más larga y define dos partes variables, o grupos, identificadas con
paréntesis que contienen los símbolos _\\\\w+_. Java intentará comparar la entrada con la expresión
y verá que el término _caracola_ encaja en la definición del grupo 1, mientras que _paloma_ encaja
en el segundo grupo. De ahí que se puedan obtener éstos usando _mat.group(1)_, o 2 en el segundo.

Para ello, debe definirse qué significan esos símbolos entre paréntesis. La doble barra indica que
lo que se desea escribir en la expresión es precisamente una contra-barra. Se debe escribir dos
veces en Java, puesto que si no coincide con el carácter de escape, como el usado con \\n para
indicar el fin de línea. Sin embargo en este caso, lo que realmente se desea escribir es una contra
barra \\.

Lo siguiente que acompaña es la letra _w_, que por sí sola no tiene valor, en cambio \\w tiene un
significado concreto y no es más que indicar cualquier carácter alfanumérico que permite definir una
palabra (_w_ de _word_); no incluye espacios, tabuladores ni signos de admiración. Pero sólo indica
1 carácter, de ahí que el último símbolo sea el _+_, indicando que lo que le antecede en la _regex_
puede aparecer 1 o más veces. Así que, la combinación en Java de \\\\w+ significa que se debe
comparar con cualquier entrada que defina una palabra (sin espacios) por larga que sea. La
concatenación de estos símbolos permite encontrar los términos de longitud distinta _caracola_ y
_paloma_.

## Entidades de _RegExp_

Por tanto, ya puede hacerse una idea el programador de por dónde van los tiros a la hora de escribir
expresiones regulares. Básicamente se trata de conocer los símbolos que puede usar y qué significa
cada uno de ellos. A continuación, se describen las entidades más importantes de _regex_:

| **Símbolo**    | **Significado**                                                                                                                                                                                                                                                                                                  |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ( )            | Los paréntesis permiten definir grupos con dos objetivos, uno para extraer la parte del _input_ compatible y además poderle aplicar un operador de recurrencia sobre el grupo que se indique.                                                                                                                    |
| \* + ?         | El primero (\*) indica que lo precedente al símbolo puede aparecer 0 o _n_ veces. El + indica que al menos debe aparecer lo anterior 1 vez, sin límite máximo. Sin embargo, ? indica que puede ocurrir 0 o 1 vez.                                                                                                |
| {n,m} {n,} {n} | El primero hace referencia a que debe ocurrir entre un mínimo de _n_ y un máximo de _m_ veces. El segundo sólo mínimo _n_ veces. Y la última exactamente _n_ ocurrencias.                                                                                                                                        |
| \\w \\W        | En minúscula hace referencia a cualquier símbolo alfanumérico considerado que puede definir una palabra. Es un alias de \[a-zA-Z\\\_0-9\]. En mayúsculas es la negación, es decir, el resto de caracteres no contemplados por _\\w_.                                                                             |
| \[ \]          | Los corchetes especifican conjuntos de letras o símbolos, sin importar el orden. Incluso permite rangos con ‘-‘ como desde la _a_ hasta la _z_ con \[a-z\]. Se puede indicar la negación de un grupo de letras, si el primer carácter es ^. Por ejemplo, \[^0-9\] significa que no puede contener ningún dígito. |
| \\d \\D        | En minúscula indica dígito, sinónimo de \[0-9\]. En mayúsculas indica no dígito o lo que es lo mismo \[^0-9\].                                                                                                                                                                                                   |
| \\s \\S        | Hace referencia a los caracteres que son espacios en blanco (\\ ), tabuladores (\\t) o saltos de línea (\\n) y retorno de carro (\\r). En mayúscula es para aquellos símbolos que no es ninguno de los anteriores.                                                                                               |
| .              | El punto es el comodín que incluye cualquier símbolo, pero solo 1. Se puede combinar con el _ para aceptar todas las entradas posibles: «_»                                                                                                                                                                      |
| &#124;         | La barra vertical indica alternación, es decir, que será compatible la entrada que cumpla el lado izquierdo o el derecho de &#124; . Por ejemplo «hola &#124; buenas».                                                                                                                                           |
| ^ $            | Respectivamente indican inicio y fin de la secuencia de entrada. De tal manera, que una expresión que incluye éstos obligará a la entrada a coincidir por completo y no sólo un segmento. O combinaciones del estilo a que empiece o termine por… Por ejemplo «^inicio.\*fin$».                                  |

Estos son los símbolos y construcciones más usados a la hora de definir expresiones regulares. Véase
los siguientes ejemplos de uso, aplicados en combinación entre algunos.

La siguiente expresión permite obtener los campos de una fecha del tipo _dd/MM/yy_ o _dd/MM/yyyy_.
Fíjese que por cada cifra se define un grupo entre paréntesis, que permitirá obtener el valor
mediante _mat.group(i)_, siendo _i_ = 1, 2 o 3.

```
// parseo de fechas
regex = "(\\d{2})/(\\d{2})/(\\d{2,4})";
```

En cambio, si se desea localizar el texto recogido entre las etiquetas de apertura y cierre de un
fichero XML para el elemento _nombre_ sería como sigue:

```
String regex = "<nombre>(.*)</nombre>";
Pattern pat = Pattern.compile(regex);
String input = "... <nombre>Pepito</nombre> ...";
Matcher mat = pat.matcher(input);
if (mat.find()) {
    System.out.println("Regexp encontrada");
    System.out.println("Sujeto:"+mat.group(1));
} else {
    System.err.println("Regexp NO encontrada");
}
```

Como puede verse en los ejemplos, no todos los caracteres se deben escapar como ‘<‘, ‘>’, ‘/’,…,
sólo deben precederse con contra barras aquellos que tienen un significado dentro de los reconocidos
por _regex_.

Por último, considérese el siguiente ejercicio que trata de escribir un algoritmo completo, en donde
el programador pretende procesar un archivo de texto, reemplazando una directiva que permita incluir
contenido dinámicamente, con el contenido de otros ficheros. La directiva podría tener el siguiente
aspecto:

```
El siguiente fichero tiene contenido fijo,
y contenido importado con:

#include: ./include.txt

pero una frase final.
```

De esta manera, el programa debería ser capaz de localizar y procesar aquella expresión regular que
sea capaz de aplicar la directiva _\\#include $<$ruta\\\_fichero$>$_, evaluándola y sustituyendo ese
fragmento por el contenido del fichero apuntado. Para simplificar el problema a resolver, se
utilizarán rutas simples de ficheros en formato Unix, tal que los directorios se separan por ‘/’. La
ruta de éstos podrá empezar por barra o por punto. Los del primer tipo se considerarán absolutos
desde la unidad de disco actual en entornos Windows, mientras que los segundos serán relativos al
directorio de trabajo del proceso Java que ejecuta el programa.

Citados los requisitos, la expresión regular que puede procesar la directiva debe contener la
siguiente forma:

```
regex = "(#include:\\s+([\\w/.-\]+\\w+\\.txt))";
```

La expresión regular construye dos grupos, uno dentro de otro. El primero se utilizará para buscar
la directiva completa y reemplazarla por el contenido del fichero. El segundo grupo será propiamente
para recoger el fichero apuntado por ruta y nombre. Justo después del literal _\\#include:_ se
indica que puede venir uno o más símbolos de espacio en blanco, de ahí _\\\\s+_. El siguiente paso
es abrir el segundo de los grupos y definir un conjunto de símbolos desordenados que son, cualquier
letra que forme una palabra, y caracteres ‘/’, ‘.’ o ‘-‘ una o más veces. Seguido, por último de
otra palabra más la extensión _.txt_.

Por tanto, el bucle principal del programa que puede llevar a cabo el objetivo del enunciado es el
siguiente, en donde se aprovecha la misma expresión regular para realizar varias búsquedas en el
fichero, tantas como directivas _\\#include_ haya, incluso las que pueda haber dentro de otros
ficheros incluidos:

```
// proceso principal
String regex = "(#include:\\s+(\[\\w/.-\]+\\w+\\.txt))";
Pattern pat = Pattern.compile(regex);
String input = getFileContent("input.txt");
Matcher mat = pat.matcher(input);
while (mat.find()) {
    String directive = mat.group(1);
    String filepath = mat.group(2);
    String includeContent = getFileContent(filepath);
    input = input.replace(directive, includeContent);
    mat = pat.matcher(input);
}
System.out.println(input);
// fin

// func para leer el contenido de ficheros
String getFileContent(String filepath) throws IOException {
    File file = new File(filepath);
    FileInputStream fis = new FileInputStream(file);
    byte\[\] bytes = new byte\[(int) file.length()\];
    fis.read(bytes);
    fis.close();
    return new String(bytes);
}
```

Para poder hacer alguna que otra prueba, el contenido inicial del primer texto debería tener al
menos la siguiente forma en el fichero _input.txt_:

```
# INICIO: fichero input.txt
Esto es una prueba de contenido no variable,
con contenido importado:

#include: ./include.txt

Y finalizado con otro contenido no variable.

## FIN: fichero input.txt
```

Y con las siguientes líneas en el fichero _include.txt_ para validar el correcto funcionamiento de
la directiva:

```
\# INICIO: fichero include.txt
Este contenido es el de include.txt
FIN: fichero include.txt
```

La salida del proceso generará las siguientes líneas por consola:

```
\# INICIO: fichero input.txt
Esto es una prueba de contenido no variable,
con contenido importado:

## INICIO: fichero include.txt

Este contenido es el de include.txt
FIN: fichero include.txt

Y finalizado con otro contenido no variable.
FIN: fichero input.txt
```

Este es sólo uno de los ejemplos de lo que puede realizarse con las expresiones regulares. Para
finalizar, indicar que el método _Pattern.compile(…)_ acepta un segundo argumento que habilita a la
expresión regular a no distinguir entre mayúsculas y minúsculas, o ingerir saltos de línea como
parte de la entrada a mitad de expresión regular y otras opciones específicas por plataforma. Puede
consultar más información en la página de Javadoc de la propia clase.


Las EXPRESIONES REGULARES son PATRONES que describen como cadenas de texto que detectan y ENCUENTRAN información fácilmente dentro de texto

QUÉ son y CÓMO se usan las REGEXPs en JAVA - //Arteco

Tutorial Java RegExp


La programación funcional o también llamadas las expresiones lambda han supuesto un salto importante
en la evolución del lenguaje de programación Java. Mostramos una introducción de cómo se usan y cómo
**escribir más con menos**.

## Qué son las funciones lambdas de Java

Las funciones lambdas es un término adoptado de la programación funcional y corresponden con
funciones de Java que normalmente son anónimas y se escriben en línea allí donde se usan. Como
cualquier función recibe cero o más argumentos y devuelven uno o ningún valor de retorno. Como
cualquier función, puede consumir métodos de otras clases y objetos. Al declararse al mismo tiempo
en donde se usa, puede acceder a las variables locales del ámbito al que pertenece, pero sólo podrá
usar estos como valores de sólo lectura, impidiendo realizar alguna modificación.

Las funciones lambdas se crearon a partir de la versión Java 8, por lo que no es posible usar su
sintaxis en versiones anteriores. Sus entidades principales están contenidas en el package
**java.util.funcional**. Sí hay que decir, que no aportan una funcionalidad que no pueda hacerse con
Java pre 8, simplemente es una manera más compacta de escribir código Java. Se puede decir de manera
resumida que **una función lambda es como una clase con un único método público**. Así que los que
no dispongan de Java 8 podrían simular un comportamiento similar creando clases parecidas a las
proporcionadas con el API de Java en el package java.util.functional.

## Entidades de java.util.functional

Antes de crear una función de tipo lambda, conviene conocer las entidades básicas que componen esta
manera de programar. Las principales entidades son interfaces con un único método que debe
implementar el programador y que estas implementaciones pueden hacerse llegar como argumentos de
métodos de otras muchas clases del API de Java. Hubo una gran modificación de las clases existentes
para aceptar este tipo de implementaciones allí donde tuviera sentido, como ocurre en las
colecciones.

Las implementaciones de estas interfaces son del tipo, consume un valor y retorna otro tipo de
valor, o produce un valor sin argumentos o produce un valor dados dos argumentos. A éstas se les
llama **unidades funcionales** porque componen una lógica interna que a priori el consumidor de esta
lógica no conoce, pero de la que sí se conoce su interfaz y por tanto la manera de relacionarse con
el resto de los objetos, o lo que es lo mismo la manera de ser invocada. Aparece de nuevo el
concepto de **cajas negras** en donde entran parámetros y salen resultados.

Las interfaces funcionales más importantes contenidas en java.util.functional son:

-   **Supplier<T>:** esta función se debe utilizar cuando se necesiten generar objetos sin requerir
    argumentos. Por ejemplo para realizar una inicialización perezosa.
-   **Consumer<T>** esta en cambio es el opuesto de `Supplier` ya que consume, acepta como argumento
    el tipo `T` sin devolver ningún valor de retorno.
-   **Function<T,R>** esta interfaz permite definir una función que acepta un parámetro de tipo `T`
    y devuelve un resultado del tipo `R` pudiendo aplicarle alguna transformación u operación.
-   **BiFunction<T,R,S>** esta interfaz permite definir una función que acepta dos parámetros de
    tipo `T` y `R`, devolviendo un resultado del tipo `S`. Normalmente serán operaciones de
    agregación u operadores binarios como la suma, resta, etc..
-   **Predicate<T>** la interfaz predicado debe devolver forzosamente un `boolean` dado un objeto de
    tipo `T`, normalmente utilizado para filtrar elementos de una colección.

El **paquete incluye más interfaces que el programador puede usar**, pero estas son las más básicas
con las que ya es posible empezar a realizar algunos ejemplos útiles y frecuentes.

## Cómo se crea una función lambda

La sintaxis cambia un poco respecto a Java tradicional, ya que se intentan no escribir los tipos de
las variables siempre y cuando no se cree alguna ambigüedad. Veamos el primer ejemplo:

```
Function<String,Integer> sizeOf = (String s) -> {
    return s.length();
};
```

O su equivalente y más compacta:

```
Function<String,Integer> sizeOf =  s -> s.length();
```

En ambos casos se está definiendo una función que dado un `String` devolverá la longitud de la
cadena de caracteres que almacene. Fíjese que el tipo de la variable de `s` se infiere
automáticamente de los tipos utilizados en `sizeOf` y que la palabra reservada `return` no es
necesaria, siempre y cuando no haya más de una sentencia en la función.

Por rara y compacta que pueda parecer la sintaxis, no es más que otra forma de escribir la siguiente
clase, de hecho esto es lo que realmente genera el compilador:

```
public class SizeOf implements Function<String,Integer>{
    public Integer apply(String s){
        return s.length();
    }
}
```

Así que para poder usar tanto la función `sizeOf` como la clase `SizeOf` en un bloque de código
cualquiera, se realizaría de la siguiente forma:

```
Integer r1 = sizeOf.apply("hola java 8");
// o
Integer r2 = new SizeOf().apply("hola java 8");
```

La ventaja de hacerlo como función, en lugar de como clase, a parte de la reducción de los literales
que acompañan a cada opción, es que el API del JDK de Java versión 8 y adelante tiene métodos que
aceptan estas funciones, reduciendo aun más la cantidad de código que se debe escribir.

Por ejemplo veamos como podemos aplicar una ordenación usando un comparador escrito en Java 8:

```
class Persona{
    String nombre;

    Persona (String nombre){
        this.nombre = nombre;
    }
}

List<Persona> personas = new ArrayList<>();
personas.add(new Persona("Pepe"));
personas.add(new Persona("Andrés"));

personas.sort( (l, r) -> l.nombre.compareTo(r.nombre));
```

Esta última función lambda es una del tipo `BiFunction` que acepta dos objetos de tipo `Persona` y
devuelve un `int` típico de cualquier comparador de java `java.util.Comparator<T>`. Tanto la función
como el comparador son compatibles, así que la función lambda anónima, se podría haber guardado en
una variable de tipo comparador para ser usado otra vez más adelante:

```
Comparator<Persona> comp = (l, r) -> l.nombre.compareTo(r.nombre));
personas.sort(comp);
```

## El uso de lambda en colecciones

El uso más habitual de lambda es en las colecciones y se utiliza para definir una operación que será
aplicada a los elementos contenidos en ésta, dejando que el Api de Java realice la iteración sobre
los elementos por nosotros, sin que tengamos que escribir ninguna sentencia de control de iteración
como `for` o `while`.

Para poder aplicar funciones lambda en colecciones, en Java 8, se introduce una nueva entidad
denominada `Stream`. Los `Stream` representan flujos de datos que pueden ser infinitos, pero en
general el flujo estará asociado a una colección finita como un `ArrayList`. Así, en un `Stream` el
programador puede «registrar» operaciones que se harán sobre una lista, por ejemplo. Para ello las
colecciones incorporar un método `.stream()` con el cual acceder al correspondiente flujo.

```
Stream<Persona> stream = personas.stream();

List<String> nombres = stream

    // filtrado de los elementos que tienen nombre nullo
    .filter(p -> p.nombre!=null)

    // aplicar una conversión, de Persona a String
    // quedándonos con el nombre
    .map(p -> p.nombre)
    // a partir de aquí se tiene un Stream<String>

    // recolectar los elementos en una lista
    .collect(Collectors.toList());
```

En el código anterior, se definen varias operaciones (filtrado, conversión y recolección) que dan
como resultado la obtención de todos los nombres de una colección de Personas en una instancia del
tipo `List<String>` sin necesidad de escribir un bucle.

Este tipo de sintaxis es muy compacta y se utiliza intensivamente en grandes proyectos para reducir
el número de líneas necesarias. Además obliga al programador a escribir unidades funcionales que son
fácilmente testeables desde pruebas unitarias con **jUnit**.

Desde luego hay muchas más opciones y funciones lambda que pueden usarse, este es sólo algunos
ejemplos de cómo utilizar las más comunes. Si estás interesado en aprender más de Java y la sintaxis
introducida en Java 8 te recomendamos que revises nuestro
[libro de java Guía Javañol](https://www.arteco-consulting.com/libro-de-programacion-java/).


La programación FUNCIONAL en Java, o también llamada Lambdas, es una gran técnica para escribir código mantenible y eficiente. ¿Te enseñamos?

Qué es y cómo se usan las LAMBDAS en JAVA - //Arteco

Introducción a Java Lambda


Spring Security es el módulo del proyecto Spring para **incorporar seguridad de acceso** a las
aplicaciones hechas con Spring Boot. Permite controles de acceso por URL entre otras muchas opciones
y es más que suficiente para proteger tu programa.

## ¿Qué es Spring Security?

Spring Security es una librería que forma parte del paraguas del proyecto Spring. Spring tiene más
de 25 sub proyectos o módulos que aportan funcionalidad que las aplicaciones pueden utilizar si lo
creen conveniente. En este caso Spring Security trata de agrupar todas las funcionalidades de
**control de acceso de usuarios** sobre proyectos Spring.

El control de acceso permite limitar las opciones que pueden ejecutar un determinado conjunto de
usuarios o roles sobre la aplicación. En esta dirección, Spring Security controla las invocaciones a
la lógica de negocios o **limita el acceso de peticiones HTTP** a determinadas URLs.

Para ello, el programador debe realizar una configuración sobre la aplicación indicando a Spring
Security cómo debe comportarse la capa de seguridad. Y aquí es una de las grandes ventajas de Spring
Security ya que permite realizar toda una serie de parametrizaciones y ajustes para un gran abanico
de posibilidades, permitiendo que el módulo se adapte bien a casi cualquier escenario de
aplicaciones realizadas con Spring IoC o Spring Boot.

Si la implementación de Spring Security no fuera suficiente, aun así, proporciona toda una serie de
interfaces Java que el programador puede implementar para cambiar el modo de comportarse de una
determinada funcionalidad, como el ir a buscar los usuarios a una fuente de datos muy particulares.

Siempre que se pueda, conviene usar las implementaciones provenientes en la librería de Spring
Security, ya que es código muy maduro ampliamente testado y además se mantiene actualizado por la
comunidad cuando se publica un aviso de seguridad o ante cualquier publicación un nuevo estándar
como pasó al liberarse el protocolo HTTP 2.

En definitiva, **Spring Security es el método más conveniente para incorporar una capa de
seguridad** en donde se desea que sólo algunos usuarios tengan acceso a métodos y controladores de
una aplicación Spring en base al uso de roles de usuario.

Además, al ser un proyecto maduro y ampliamente utilizado, es posible encontrar implementaciones
incluidas de serie para los principales sistemas de seguridad de usuarios más desplegados en el
mundo del desarrollo de software o en la administración de sistemas de TI, como LDAP o Kerberos
entre otros.

## ¿Cómo incluir Spring Security en una aplicación web?

Añadir Spring Security en cualquier proyecto Spring de Java es muy sencillo, sobre todo si se ha
utilizado la capa de auto-configuración de Spring MVC y Spring IoC denominada Spring Boot. Si deseas
incorporar Spring Security en una aplicación Java o Spring MVC conviene que consideres la migración
a Spring Boot antes de proceder con los siguientes pasos, ya que el uso de **Spring Boot simplifica
enormemente** las acciones de configuración que debe realizar el desarrollador para poner en marcha
cualquier aplicación Spring. Puedes consultar el artículo
[tutorial de Spring Boot y Thymeleaf](https://www.arteco-consulting.com/tu-primera-aplicacion-con-spring-boot/)
para ver los pasos necesarios en la configuración de una aplicación de este tipo.

Suponiendo que tienes una aplicación Spring Boot en marcha gestionado por Maven, en donde el fichero
pom.xml tiene como parent el artefacto _spring-boot-starter-parent_, lo primero que se debe hacer es
incorporar el conjunto de **dependencias provenientes de _spring-boot-starter-security_**. Ésta
traerá de forma transitiva el resto de librerías JARs que Spring necesitará para aplicar los
mecanismos de seguridad requeridos.

Por sólo incluir la dependencia, si el programador no realiza ninguna configuración adicional,
Spring Boot **de manera predeterminada protegerá todo el acceso** a la aplicación, impidiendo que
ningún usuario no identificado pueda invocar a cualquier controlador. Este mecanismo tan restrictivo
suele ser suficiente para pequeñas aplicaciones donde sólo se necesita restringir el acceso de forma
general, pero queda algo reducido en aplicaciones donde hay secciones accesibles y otras protegidas,
dependiendo de si el usuario está identificado o de si éste tiene un rol determinado.

Como el resto de aspectos configurables de Spring Boot, en el fichero de configuración de la
aplicación, application.properties o application.yml, hay varias propiedades que pueden ajustarse
para controlar el comportamiento base de Spring Security.

Las **propiedades más importantes de Spring Security** son:

```
spring.ldap.\* = ...                    # propiedades correspondientes a integración con LDAP
spring.security.oauth2.\* = ...         # parámetros para OAuth2 y JWT
spring.session.\* = ...                 # configuraciones para la sesión HTTP, con persistencia SQL opcional

spring.security.user.name = user        # usuario por defecto
spring.security.user.password =         # password por defecto
spring.security.user.roles =            # roles por defecto
```

De esta manera, sólo por incluir la dependencia, en el fichero de propiedades de la aplicación puede
indicarse un usuario y clave por defecto que podrá usarse para tener acceso a los controladores, y
como consecuencia a las diferentes pantallas HTML de la aplicación. Cuando el usuario intente
acceder a cualquier URL de la aplicación, Spring Boot y el **Security Filter de HTTP redirigirá al
usuario al formulario** de identificación, donde solicitará al usuario a insertar el nombre y
password para proceder. En ese formulario se debe indicar los valores fijados en
_spring.security.user.name_ y _spring.security.user.password_. Si el usuario ha introducido los
valores correctos, se considera al usuario autenticado, y sin tener en cuenta el rol, dejará
continuar al usuario con una navegación normal.

Se debe tener en cuenta que la configuración por defecto **no incluye el auto registro de
usuarios**. En el caso de necesitar que los usuarios puedan registrarse automáticamente, por ejemplo
con un email, se deberá programar el mecanismo por el cual se confía en la información proporcionada
por el usuario procediendo a la creación de éste en la tabla de datos o fuente de usuarios
confiables usada por la aplicación.

## ¿Cómo proteger secciones de la aplicación?

Si la protección de forma global a toda la aplicación no se adapta a tus necesidades, probablemente
será porque hay secciones que deseas que sean accesibles mientras que otras estén protegidas para un
determinado número de usuarios. Si este es el caso, al paso anterior de incluir la dependencia
_spring-boot-starter-security_ se debe acompañar con la creación de una clase de configuración de
Spring anotada con **@Configuration**, en donde se podrá especificar qué secciones estarán
habilitadas y cuáles no en función de los patrones de URL. Por comodidad, conviene que esta clase a
crear extienda a **WebSecurityConfigurerAdapter** ya que simplifica la implementación.

Por ejemplo, supóngase que la aplicación web que se está desarrollando tiene una parte pública
compuesta por páginas HTML, otra parte protegida y accesible para usuarios autenticados (sin
importar su rol) y por último otra sección accesible únicamente para el o los usuarios con el rol de
administrador. Para poder llevar a cabo esta configuración se debe segmentar los accesos por URLs de
tal manera que permita realizar la siguiente distribución:

-   **/admin/\*** Patrón de URL que agrupa las funcionalidades del administrador
-   **/user/\*** Grupo de funcionalidades de los usuarios autenticados
-   **/\*** Resto de accesos públicos a la aplicación

Para que el mecanismo de control de acceso por URL funcione correctamente conviene hacer esta
división por espacios de URL e incluir las secciones más restrictivas primero, dejando al final las
más generales. Así se simplifica el número de configuraciones necesarias a realizar.

La configuración de Spring Security necesaria para este supuesto quedaría de la siguiente manera:

```
@Configuration
public class ArtecoCmsSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .regexMatchers("/admin/.\*").hasRole("ADMIN")
                .regexMatchers("/user/.\*").authenticated()
            .anyRequest()
                .permitAll()
            .and()
                .formLogin();
    }

}
```

Con esta simple configuración se ha separado el espacio de direcciones que pueden llegar a la web en
base a tres conjuntos, los que contienen _/admin_ que requerirá que el usuario esté identificado y
además disponga del rol de ADMIN como mínimo. La segunda sección delimitada por direcciones que
comiencen por _/user_ que bastará que el usuario haya pasado por éxito a través del formulario de
identificación. Y por último el resto de URLs quedarán abiertas para cualquier usuario identificado
o no.

La última línea de configuración correspondiente a **formLogin** habilita el formulario de
identificación de usuario, que se interpondrá en el usuario automáticamente si trata de acceder a
alguna URL que requiera autenticación o algún ROL.

## Cómo administrar los usuarios del programa

Tener un sólo usuario en la aplicación puede ser útil en ciertas ocasiones, aunque desde luego es un
escenario algo limitado para aplicaciones abiertas en Internet. Por norma general se usarán varios
usuarios, presumiblemente con roles de acceso diferentes para limitar las acciones que pueden
realizar cada tipo de usuario.

Para ello necesitamos añadir una **fuente de usuarios** administrador por la aplicación y que serán
usados en el proceso de autenticación por Spring Security. De esta manera, nuestra aplicación puede
incorporar un mecanismo de registro de usuarios que puedan autenticarse.

Para que Spring pueda obtener la información de un usuario durante el proceso de login, se
solicitará al conjunto de clases Java registradas en el contexto de Spring, de alguna que implemente
la interfaz **UserDetailsService**:

```
package org.springframework.security.core.userdetails;

public interface UserDetailsService {

        UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

}
```

Esta interfaz tiene un único método de obligada implementación que es aquel que devuelve los
detalles de un usuario **UserDetails** dado un nombre de usuario, el que trata de ingresar en la
aplicación. Por tanto será obligatorio implementar un bean con esa interfaz dando cuerpo a ese
método, por ejemplo como el siguiente:

```
@Component
public class MyUserDetails implements UserDetailsService {

    private final UserRepository userRepository;

    @Autowired
    public ExtranetUserDetails(UserRepository userRepository) {
        this.userRepository = userRepository;
    }


    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<MyUser> userDb = userRepository.findByUsername(username);
        if (userDb.isPresent()) {
            MyUser user = userDb.get();
            List<Permission> permissions = user.getPermissions();
            Set<String> roles = new HashSet<>();
            if (!CollectionUtils.isEmpty(permissions)) {
                for (Permission p : permissions) {
                    roles.add(p.getRol().name());
                }
            }
            return org.springframework.security.core.userdetails.User
                    .withUsername(username)
                    .roles(roles.toArray(new String\[0\]))
                    .password(user.getPassHash())
                    .build();
        } else {
            throw new UsernameNotFoundException("Usuario no encontrado!");
        }
    }

}
```

La implementación de este bean dependerá de dónde tenemos registrados los usuarios. Normalmente
éstos estarán en una tabla de la base de datos, así que ya sea con SQL nativo o usando JPA con
EntityManager o a través de Spring Data Repositories deberemos consultar la fila asociada según el
nombre de usuario. Una vez localizado sólo restará convertir o mapear ese objeto a uno esperado por
Spring, del tipo UserDetails.

Por último, en la clase de configuración de Spring Security registraremos nuestra clase recién
creada:

```
@Configuration
public class ArtecoCmsSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // ... código omitido
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetails()).passwordEncoder(new BCryptPasswordEncoder());
    }

    @Autowired
    public MyUserDetails myUserDetails(UserRepository userRepository) throws Exception {
        return new MyUserDetails(userRepository);
    }

}
```

**¡Y listos!** Con esta simple configuración ya se tiene una aplicación con gestión de usuarios
capaces de identificarse en Spring Security y por tanto usar todos los mecanismos que esta capa de
seguridad ofrece.

Se debe tener en cuenta que en el ejemplo se ha optado por usar un **PasswordEncoder** que permite
almacenar las contraseñas de los usuarios de forma encriptada en la base de datos. Esta manera es
una gran aliado para evitar fugas de información importantes si algún usuario malintencionado
pudiera tener en algún momento acceso a la tabla de usuarios, evitando que se haga con las
credenciales de los usuarios.

Cuando tenga que implementarlo en su aplicación no debe olvidar proporcionar una implementación
válida como UserRepository para que pueda obtenerse el usuario solicitado. Recuerde que este
información puede proceder de una base de datos o también de algún archivo, o incluso de algún
servicio remoto para la centralización de usuarios como LDAP.


Spring Security es la referencia para añadir seguridad y CONTROL DE ACCESO a las aplicaciones Java Spring Boot. Revisa cómo se hace

Añade SEGURIDAD a Java con SPRING SECURITY - //Arteco

Securizar con Spring Boot


Java es el lenguaje de programación más usado en las empresas que desarrollan su propio software.
Analizamos las principales características y describimos porqué **es el mejor lenguaje de
programación** para aprender a programar o para desarrollar cualquier proyecto web.

## Java es gratis

Desde su creación en 1995, por Sun Microsystem, el lenguaje de programación Java se ha orientado
principalmente a resolver los problemas relacionados con el desarrollo de software, desde el punto
de vista empresarial, aportando un marco de trabajo más productivo y que permitiera generar software
más mantenible y escalable.

En 2010 la empresa creadora de Java, fue adquirida por Oracle en una serie de negociaciones que
obligaba al nuevo propietario a seguir con el proceso de liberalización de la tecnología bajo la
licencia GNU GPL de forma gradual, en unas acciones que empezaron con anterioridad y de forma muy
tímida a partir del 2007.

Hoy en día, la plataforma OpenJDK es el encargado de publicar las últimas versiones tanto del
lenguaje Java como de la máquina virtual JVM necesaria para ejecutar los programas escritos en este
lenguaje, siguiendo las directrices marcadas por la **Java Community Process con más de 1200
miembros**, entre los que están Google, Adobe, Boeing, Oracle, Twitter y otros. why-use-java Java
tiene tipado estático

---

Para asegurar que el software escrito es robusto, Java proporciona un tipado estático de las
variables. Es decir, las variables sólo son de un tipo y éste no puede variar con el tiempo. Esta
aparente limitación, **es un salvo conducto** para aplicaciones empresariales de gran envergadura en
donde participan grupos de programadores escribiendo miles de líneas de código. Las actividades de
análisis de código, como las que realiza el compilador, permiten detectar un gran número de errores
en tiempo de compilación, siempre preferible que encontrarlos en durante la ejecución. Sobre todo
cuando la aplicación está corriendo en sistemas empotrados o pequeños dispositivos.

## Java es portable

Java es el lenguaje de programación, y está orientado a objetos y tiene tipado estático. Sin
embargo, su compilación no genera código nativo, si no que genera código para ser ejecutado en una
máquina virtual, JVM. La Máquina Virtual de Java, es un reproductor capaz de ejecutar programas
compilados en Java (y de otros lenguajes) abstrayendo de las particularidades de cada plataforma,
**ofreciendo al programador una única interfaz de programación**. Esto provoca que los programas
escritos con Java sean independiente y por tanto portables. Los binarios resultantes de la
compilación, pueden ser ejecutados tal cual en un sistema Windows como Mac o Linux sin necesidad de
modificar ni una coma.

Como consecuencia de su portabilidad, se requiere tener instalada la JVM en todos los sistemas que
deseen ejecutar programas escritos en Java. La comunidad [OpenJDK](https://openjdk.java.net/) se
encarga de mantener todas las implementaciones de la JVM para cada una de las plataformas más
habituales.

## Java es rápido

Es un mito que Java sea lento. Originariamente se justifica porque la JVM debe interpretar los
programas escritos en Java y ésta en sus inicios carecía de optimizaciones potentes como hoy en día.
Sin embargo y de forma planificada, a partir de la versión 6 de Java, la JVM incluye un compilador
que genera **código nativo en tiempo de ejecución** de forma transparente al programador y al
usuario. Además, durante esa compilación, se aplican las técnicas de optimización más avanzadas del
sector, y no sólo se basan en cómo está escrito el código, sino también cómo ha sido la ejecución
reciente y cómo se cree estadísticamente que serán las siguientes iteraciones. Esta batería de
optimizaciones provoca que Java tenga tiempos similares a programas similares escritos en C/C++.

Hoy en día, en versiones más modernas como Java 13, el número de optimizaciones de código, nivel de
paralelismo y el gran trabajo de grupos de investigación puede afirmarse con rotundidad que Java es
uno de los lenguajes con mejor rendimiento del panorama del software de propósito general, muy
superior que al de otros lenguajes dinámicos o de tipado débil.

## Java tiene un gran ecosistema

Desde su nacimiento, Java ha presentado una gran penetración en el mercado del desarrollo de
software a nivel empresarial. Su madurez y fiabilidad ha provocado que muchas empresas apuesten por
este lenguaje a la hora de afrontar grandes inversiones en la elaboración de sus propias plataformas
de información. Como resultado de esa adopción, tanto programadores como empresas y organizaciones
participan activamente en el desarrollo de herramientas y librerías útiles (muchas de ellas Open
Source) para solventar los problemas habituales a los que debe afrontar el programador.

Como mención especial, las organizaciones como [Apache Foundation](https://www.apache.org/) y
[Eclipse Foundation](https://www.eclipse.org/), entre otros como Google y Netflix, han aportado
muchas de las librerías y utilidades de uso diario en el desarrollo de software, todas ellas Open
Source con licencias muy permisivas.

## Java tiene un gran número de programadores

Es difícil saber si gracias al gran número de programadores hay un gran ecosistema, o al revés. Pero
lo que sí se sabe es que encontrar programadores conocedores de Java es una tarea más fácil que
hallar a aquellos que dominan otros lenguajes menos implantados.

![](/post/021/tiobe-java.png)

![](/post/021/tiobe-java.png)

También se sabe que Java es uno de los lenguajes que se ha posicionado entre el segundo y **primer
puesto como lenguaje de programación más utilizado** en todo el mundo en los últimos casi 20 años,
rivalizando con C/C++ según el tradicional índice [TIOBE](https://www.tiobe.com/tiobe-index/).

## Java tiene los IDEs más avanzados

Tradicionalmente Java ha dispuesto siempre del beneficio de incorporar los IDEs o **editores de
programación más avanzados** del mercado, prácticamente su totalidad sin coste por uso ayudando a su
implantación en las empresas. Estos editores permiten la compilación incremental, asistencia de
escritura en código, refactorizaciones, búsqueda de documentación del API y muchas otras funciones
más.

Desde [Netbeans IDE](https://netbeans.org/), a [Eclipse IDE](https://www.eclipse.org/ide/) y más
recientemente [Intellij](https://www.jetbrains.com/es-es/idea/) son los editores de programación más
usados, incluso para otros lenguajes, llenos de integraciones con herramientas típicas como **Git**
para el control de versiones o **Maven** y **Gradle** para la construcción de aplicaciones.

## JVM es políglota

La Máquina Virtual de Java se ha convertido en los últimos años en un reproductor muy avanzado capaz
de ejecutar código proveniente de diferentes lenguajes de programación, siendo **Java** el más
habitual. Los usuarios pueden optar por otros lenguajes con características diferentes o
especializados en un escenario particular. Algunos ejemplos son **Groovy** si se desea el dinamismo
que ofrece el scripting. **Scala** o **Clojure** si se busca un lenguaje funcional, o **Kotlin** si
se está orientado al desarrollo de aplicaciones móviles para **Android**, entre otros muchos
lenguajes.

Todos ellos se benefician del API único que proporciona la JVM para cualquier plataforma. Incluso es
posible integrar diferentes lenguajes en una misma aplicación para ser ejecutada por la JVM. Otros
lenguajes también disponibles son **Javascript**, **Jython** o **JRuby** que favorecen la
reutilización de librerías o frameworks existentes.

## Java tiene soporte de las principales empresas

Como se ha citado con anterioridad, Java disfruta del apoyo de las principales empresas tecnológicas
puesto que muchas de ellas han desarrollado parte de sus plataformas usando este lenguaje. Miembros
o no del JCP, un gran número de empresas reconocen usar internamente Java en algunos de sus
productos o servicios. Todas ellas son empresas de primer nivel como Google, Facebook, Twitter,
Oracle y muchas más. Y **destacan de forma unánime la solidez y el fácil mantenimiento** de las
aplicaciones empresariales desarrolladas, sobre todo en proyectos donde participan un gran número de
programadores y por tanto están sometidas a evoluciones constantes.

## Java está en continua evolución

Desde que OpenJDK está al mando de Java y la JVM, el compromiso del colectivo que lo conforma es
sacar frecuentes versiones que incorporen las mejoras propuestas por la comunidad **mendiante el
proceso Java Community Reques (JCR)**, en donde se proponen, valoran e implementan las peticiones de
nuevas características de Java o de la máquina virtual, con el fin de tener un marco tecnológico que
se adecue a las nuevas situaciones y hardware que vaya surgiendo con el paso del tiempo. El objetivo
es que Java sea capaz de afrontar los desafíos tecnológicos tan cambiantes como las recientes
arquitecturas web en la **nube** y basados en **contenedores virtualizados** sin olvidar su orígenes
en sistemas empotrados y de tiempo real.

---

### Conclusiones

Con todas estas justificaciones esperamos que veas a Java como un gran lenguaje digno de ser
utilizado en tus nuevos proyectos. Nosotros lo utilizamos a diario y la mayor parte de nuestros
clientes nos exigen la entrega de los trabajos usando Java.

Ayúdanos a dar a conocer las características que definen a Java como un gran lenguaje de
programación, merecedor del esfuerzo en su aprendizaje y utilización. O por el contrario, si
consideras que Java no se merece el reconocimiento citado, déjanos un comentario. Estaremos
encantados de saber tu opinión o experiencia.


JAVA es el lenguaje de PROGRAMACIÓN más usado en la EMPRESA. ¿Por qué? es COMPILADO y de TIPADO ESTÁTICO, ideal para grandes proyectos

Por qué DEBES usar JAVA para programar tus proyectos - //Arteco

Ventajas de Java


El objetivo de esta práctica es la realización de un **intérprete de comandos** que permita al
usuario introducir sentencias desde el teclado de forma interactiva. A través de esos comandos el
usuario podrá ejecutar instrucciones que permitan manipular el sistema de ficheros de forma básica

## Instrucciones de implementación

Las operaciones que debe poder ejecutar el usuario a **través del terminal** son:

-   **ls** > listar los ficheros del directorio actual.
-   **cd** _arg_ → cambiar de directorio.
-   **cat** _arg_ → imprimir el contenido de un fichero.
-   **rm** _arg_ → eliminar el fichero o directorio indicado.
-   **mkdir** _arg_ → crea el directorio indicado en el nivel actual.
-   **cp** _arg1_ _arg2_ → copiar el fichero de arg1 en la ubicación arg2.
-   **append** _arg1_ _arg2_ → añade el contenido de arg2 al final del archivo indicado en arg1.
-   **replace** _arg1_ _arg2_ _arg3_ → reemplaza el contenido del fichero indicado en arg1 buscando
    las referencias de arg2 para sustituirlas por arg3.

Para poder llevar a cabo esta tarea, el programador primero deberá crear un proyecto Maven
mono-módulo, usando las instrucciones indicadas en el capítulo **Construcción con Maven**. El
asistente dejará a disposición de éste una clase conteniendo el método public static void main que
se usará para crear el bucle principal.

El aplicativo deberá leer la entrada del usuario mediante **System.in** mientras que el usuario no
escriba **exit**. Hasta entonces, se ejecutará cada uno de los comandos escritos por el usuario. El
bucle principal delegará la ejecución de la acción solicitada en una clase determinada. Se deberán
crear tantas clases específicas como comandos enumerados.

Para validar el desarrollo, debe haber tantos **test unitarios** como los necesarios para alcanzar
una cobertura por encima del 90 % del código fuente.


Enunciado de la PRÁCTICA 1 de programación para aprender a programar en Java descrito en el libro de Java Guía Javañol

Libro tutorial Java - Guía Javañol - Práctica 1 - Ficheros - //Arteco

Práctica 1 Java - Guía Javañol


El objetivo es crear un sistema que permita jugar a hundir la flota contra la CPU en modo consola a
través de órdenes introducidas por el usuario en el terminal de comandos.

## Instrucciones para la implementación

El juego debe consistir en la elección de casillas del tablero del oponente mediante un sistema de
turnos y organizado en dos fases. La **primera fase** es la de colocación de los barcos en una
matriz y la **segunda fase** comienza el sistema de turnos para lanzar misiles contra el oponente.

El proyecto también deberá ser generado con **Maven** y con todos los casos de test unitarios que
permitan validar el 90 % del código fuente escrito.

Los **requisitos del sistema** son:

-   La interacción del usuario con el sistema de juego se hará mediante comandos por consola. Así
    que se debe crear un intérprete de comandos que lea la entrada del usuario. Posibilidad de usar
    librerías como **commons-cli** para tal fin.
-   Las operaciones que debe ofrecer ese intérprete como mínimo son: **comenzar** par- tida,
    **lanzar** misil, **imprimir** partida (tablero e inventario) y **salir**.
-   La colocación de los barcos en el tablero, tanto para el jugador como para la CPU será
    aleatoriamente mediante tres variables aleatorias a través de **Math.random()**. Las variables
    indicarán posición **X** e **Y** y si es **horizontal o vertical**. Se permite que los barcos se
    toquen, dejando opcional la inclusión de algún mecanismo para evitarlo.
-   Se debe crear un **log** en un fichero de texto conteniendo las acciones que se realizan en
    todas las partidas, tanto las acciones del jugador como las de la CPU, marcando claramente el
    momento de inicio y fin de las partidas y su resultado.
-   Tanto el tamaño de la matriz como el inventario de barcos debe ser configurable. Se supondrá una
    matriz cuadrada **N x N**. La variable global **N** determina el tamaño. El inventario vendrá
    dado por una instancia de **List<Flota>**. Siendo la clase **Flota = {nombre, numero,
    tamanyo}**. Ambas determinarán cuantos barcos se deberán colocar en cada partida. Se deja
    opcional que el usuario pueda cambiar la configuración por comandos.
-   Una **configuración** posible es:
    -   Tamaño de matriz por defecto: N = 10
    -   1 portaaviones que ocupe 5 casillas
    -   2 cruceros, que ocupen 4 casillas
    -   3 destructores, que ocupen 3 casillas
    -   2 fragatas, de 2 casillas
    -   4 submarinos, de 1 casilla
-   Si pasado un tiempo el usuario no indica su lanzamiento en medio de una partida en marcha, se le
    devuelve el turno automáticamente a la CPU para que ejecute su turno.


Enunciado de la PRÁCTICA 2 de programación para aprender a programar en Java descrito en el libro de Java Guía Javañol

Libro tutorial Java - Guía Javañol - Práctica 2 - La Flota - //Arteco

Práctica 2 Java - Guía Javañol


El objetivo de esta práctica es crear un servicio accesible por red que **permita reservar plazas**
hoteleras sobre un hotel imaginario durante un mes. Este servicio será consumido por una segunda
aplicación Java que actuará de cliente y que interactivamente permitirá al usuario realizar
operaciones sobre el sistema de reservas.

## Requisitos funcionales

Las reservas siempre serán sobre días completos desde las 12 am hasta las 12 am del día siguiente.
Aunque una reserva implique dos días, sólo se considerará que hay una reserva por día y es aquella
que tiene la habitación reservada, por ejemplo a las 19h. Se entenderá que todas las habitaciones
son dobles, con un único precio base por habitación.

El hotel tendrá **dos tipos de habitaciones**, normal o suite, con precios diferentes por tipo.
También con **dos tipos de régimen** cada una de ellas: media pensión o completa.

El régimen representará un % de incremento sobre el precio de la habitación. Una reserva será para
sólo una habitación. Actualmente el hotel sólo dispone de 5 habitaciones regulares y 2 suites.

## Requisitos técnicos

El cliente y el servicio intercambiarán información mediante algún sistema de serialización de
objetos, por ejemplo JSON. Tanto el servidor como el cliente usarán **Sockets TCP/IP** para
establecer la conexión y poder intercambiar documentos. Los datos de las habitaciones disponibles,
reservas y precios provendrán de una base de datos SQL usando JPA y **QueryDSL**.

Para la gestión de disponibilidad se debe implementar un **calendario** usando cualquier estructura
de información que permita saber qué habitaciones hay libres cada día de agosto. Se debe incorporar
algún **mecanismo de sincronización** que garantice que NO se hacen dos reservas sobre la misma
habitación en los mismos días.

El servidor debe exponer las siguientes **operaciones**:

-   **availability** Devuelve el listado de TIPOS de habitaciones disponibles entre dos fechas. Cada
    registro devuelto debe contener el TIPO de habitación al que hace referencia y una lista de los
    regímenes posibles para la habitación indicando el precio estándar por día para ese régimen (y
    ese tipo de habitación). Si no hay ninguna habitación disponible de un tipo, obviamente ese tipo
    se debe omitir en la respuesta. Entradas:

    -   **from** LocalDate
    -   **to** LocalDate
    -   **roomType** Tipo de habitación (opcional)Salidas:

    -   Objeto de tipo **HotelAvailResponse** con la disponibilidad contenida dentro.

-   **valuate** Valorar una disponibilidad. Es decir, dadas dos fechas, el tipo de habitación y el
    régimen solicitado, obtiene el precio total de la posible reserva. Devuelve error si no está
    disponible. Entradas:

    -   Objeto validado del tipo **PreBookingRequest** con todos los campos obligatorios.

        -   **from** LocalDate
        -   **to** LocalDate
        -   **roomType** Tipo de habitación
        -   **mealPlan** Tipo de régimenSalidas:

    -   Objeto de tipo **PreBookingResponse** conteniendo los parámetros de entrada, más un
        **timestamp** de cuándo se realizó la operación y el precio de la posible reserva.

-   **confirmation** Realiza la reserva. Dadas dos fechas, el tipo de habitación, el régimen
    escogido y el código de cliente (un **String** cualquiera). Ejecuta de nuevo una valoración y si
    tiene éxito bloquea dicha habitación durante los días indicados. Devuelve información acerca de
    la reserva: el precio final, el identificador de la habitación y el identificador de la reserva.
    Esta operación debe modificar el calendario y la tabla de reservas. Entradas:

    -   Objeto validado del tipo **BookingRequest** con todos los campos obligatorios.

        -   **from** LocalDate
        -   **to** LocalDate
        -   **roomType** Tipo de habitación
        -   **mealPlan** Tipo de régimen
        -   **customer** Tipo de String que identifica al clienteSalidas:

    -   Objeto de tipo **BookingResponse** que contiene toda la información de la reserva.

-   **cancellation** Dado un identificador de una reserva, libera la habitación para las fechas de
    la reserva dejando el calendario y la base de datos actualizada. Entradas:

    -   **bookingId** Identificador de la reservaSalidas:

    -   Confirmación de la operación realizada correctamente o error si no se encuentra la reserva
        en el sistema.

-   **bookings** Listado de reservas, con posibilidad de indicar un rango de fechas opcional como
    filtro. Devuelve el listado de reservas confirmadas no canceladas. Produce la misma información
    que la confirmación, pero con aquellas reservas que estén en el intervalo. Entradas:

    -   **from** LocalDate para el inicio del rango
    -   **to** LocalDate para el fin del rangoSalidas:

    -   Listado de reservas en forma de **Collection<BookingResponse>**.

## Notas de implementación

Para facilitar el inicio del proyecto, el programador deberá definir cómo serán los documentos que
intercambiarán el servidor y el cliente. Como guía se deja una posible definición del documento de
respuesta de disponibilidad en JSON indicando qué clases Java producen tal documento.

La respuesta de disponibilidad esperada por el servidor debe contener el siguiente formato:

```
    {  "availability" : [
       {
         "roomType" : "regular",
         "prices" : [
            {
              "mealPlan" : "MP",
              "dayPrice": 100
            },
            {
              "mealPlan" : "PC",
              "dayPrice": 150
            }
          ]
        }, {
          "roomType" : "suite",
          "prices" : [
            {
               "mealPlan" : "MP",
               "dayPrice": 170
            },
            {
               "mealPlan" : "PC",
               "dayPrice": 200
            }
           ]
        }
      ]
    }
```

El anterior mensaje JSON será generado automáticamente de la serialización del siguiente modelo
Java:

```
    public class HotelAvailResponse{
        private List<RoomAvail> availability;
        /* getters and setters */
    }

    public class RoomAvail{
        private String roomType;
        private List<RoomPrice> prices;
        /* getters and setters */
    }

    public class RoomPrice{
        private String mealPlan;
        private Float dayPrice;
        /* getters and setters */
    }
```


Enunciado de la PRÁCTICA 3 de programación para aprender a programar en Java descrito en el libro de Java Guía Javañol

Libro tutorial Java - Guía Javañol - Práctica 3 - Reservas - //Arteco

Práctica 3 Java - Guía Javañol

Recursos y TUTORIALES para iniciarse en el mundo de la programación con Java y el desarrollo de aplicaciones móviles y empresariales

QUICK START para programar con Java/Springboot - //Arteco

Tutorial Java y Spring Boot


SpringBoot se ha convertido en **el framework de Java más usado en el mundo**, por encima de los
estándares J2EE. A continuación explicamos los motivos de porqué es el conjunto de librerías más
usado y porqué conviene usarlo al empezar cualquier proyecto web.

## SpringBoot es gratis

SpringBoot es un módulo del proyecto de Spring que fue creado para simplificar el desarrollo de
aplicaciones con Spring Framework bajo licencia Apache 2.0. Pone a nuestro alcance una
infraestructura para el desarrollo de aplicaciones en una **plataforma de lenguaje Java de código
abierto**, que hace mucho más fácil la vida de los programadores ahorrando tiempo y costes, sin por
ello sacrificar control sobre el código ni rendimiento.

Aunque el proyecto de Spring sale a la luz en 2003, es en 2014 donde se puede ver su versión 1.0 del
modulo de SpringBoot, hasta hoy día que tenemos la versión 2.2.5 released con soporte para Java 13.

## SpringBoot funciona sobre la JVM

Una de las grandes ventajas de trabajar sobre JVM, es que permite desarrollar nuevas aplicaciones,
migrar o reutilizar código de cualquier proyecto ya desarrollado en **Java, Kotlin o Grovy** y
ademas sobre uno de los entornos más extendido y potente en estos días como lo es JVM, con el
soporte que esto significa.

La máquina virtual habilita a cualquier aplicación Spring, y Java en general, a ser ejecutada en los
principales sistemas operativos, tanto de servidores, como máquinas virtuales o en computadoras
personales.

## SpringBoot permite hacer Webs y Microservicios

Actualmente hay una alta tendencia empresarial a migrar las aplicaciones sobre una arquitectura de
desarrollo de microservicios, o Startups que directamente utilizan esta arquitectura por su
flexibilidad gracias a la separación de responsabilidades en microservicios independientes, que
permiten entrar y/o migrar entre los diferentes modelos de negocio. La separación en microservicios
permite realizar aplicaciones especializadas y fácilmente reutlizables dando mucha potencia y
flexibilidad a los sistemas de información.

Esta gran **versatilidad de SpringBoot** hace que podamos abarcar prácticamente cualquier reto en el
ámbito profesional de la programación con su ayuda.

Al mismo tiempo puede usarse Spring Boot para realizar aplicaciones web tradicionales o multi página
en donde el HTML es generado dinámicamente en el lado del servidor, antes de ser entregado al
navegador web del usuario.

## SpringBoot es rápido

Imagínate no tener que configurar contenedores ni servidores web Apache Tomcat, tener la estructura
de tu aplicación y autoconfigurado tu framework Spring, tener todas tus dependencias en un formato
legible en un archivo POM para su gestión Maven, además de la conexión a tu base de datos, todo en
cinco minutos. No es ninguna exageración, el automatismo que ofrece SpringBoot te permite empezar a
**desarrollar prácticamente de inmediato y desplegar tu aplicación** sin complicaciones, sin
sacrificar nada a cambio.

Con Spring Boot es rápido desarrollar y es rápido de ejecutar. Apoyado en todo el framework de
desarrollo Spring, las aplicaciones hechas con esta tecnología está optimizadas para altas cargas de
trabajo con un mínimo consumo de memoria, gracias a que la mayoría de entidades son _singletons_ y
por tanto objetos java reutilizados entre _threads_. Esta aproximación mantiene mínima la memoria
RAM necesaria por cada cliente simultáneo, convirtiéndolo en sistemas óptimos para entornos web con
miles de peticiones por segundo.

## SpringBoot tiene un gran ecosistema

Spring, nacido en 2003, se hizo famoso en la comunidad de programadores Java en parte gracias a una
documentación bien estructurada y completa, por encima de la media general que solemos ver en
proyectos de código abierto y que a día de hoy aún agradecen.

En 2004 los desarrolladores formaron su propia compañía y surgió The Spring Forum, el foro de la
comunidad de desarrolladores con Spring que dió a conocer aún más el framework, sin dejar de crecer
y convertirse en la fuente de información más importante. Sólo en sus inicios, ya se reunían más de
300 programadores en conferencias de Spring.

## SpringBoot tiene un gran número de programadores

En 2017 un blog de la web jRebel publicó un gráfico del índice de uso de diferentes frameworks de
Java, basándose en los servicios de LinkedIn, StackOverflow, GitHub y búsquedas sobre cuestiones
específicas de Spring en el motor de Google. De entre los 17 frameworks analizados, **Spring MVC
quedó el primero** seguido por JSF que una diferencia notable:
[Java Web Frameworks index](https://www.jrebel.com/blog/java-web-frameworks-index)

## Spring Boot viene con baterías incluidas

Spring es todo un marco de trabajo completo para desarrollar aplicaciones empresariales. Tiene todo
lo necesario para abarcar las funcionalidades esperadas de cualquier aplicación profesional. Desde
gestión de configuraciones, seguridad, capa de acceso a datos SQL y noSQL, inyección de
depencencias, monitorización, testing, etc…

La documentación del proyecto es una de las mejores del mundo Open Source y cualquier usuario
encontrará la información con la que poder usar cualquiera de sus módulos, que se mantienen
actualizados con cada versión y con cada recomendación de la W3C para el desarrollo de aplicaciones
web seguras.

## SpringBoot es políglota

Gracias al uso de la JVM, se amplia el abanico de posibilidades de integraciones entre diferentes
lenguajes de programación, bases de datos, etc… dando la oportunidad de utilizar la tecnología que
mas convenga a cada modelo de negocio.

## SpringBoot tiene soporte de las principales empresas

Al estar basado en la plataforma JVM disfruta de la fama y apoyo de todos los proyectos y grandes
empresas que hacen uso de esta y de las que en particular hacen uso de Spring como son: MIT, Intuit,
PedidosYa, trivago, MercadoLibr, Google Cloud…

## SpringBoot está en continua evolución

La idea de Spring es que como programador te centres en desarrollar tu aplicación y no malgastes
tiempo ni recursos en procesos repetitivos ni configuraciones.

El ecosistema de Spring es un ecosistema de módulos que podemos añadir a nuestra aplicación según
necesitemos o no para conseguir este fin. Podemos mencionar por importancia y funcionalidad:
**Spring Data** (simplificación de acceso a los datos), **Spring Security** (autenticación y
seguridad) y **SpringBoot** (autoconfiguración y despliegue) que es uno de los módulos que se vuelve
mas imprescindible.

En la actualidad podemos ver en la página oficial de Spring como tienen en continua evolución **25
proyectos y 7 proyectos más** para su futuro desarrollo:
[Spring Projects](https://spring.io/projects).

## Conclusiones

Todos estos motivos hacen que cada vez más empresas nos soliciten el desarrollo de las sus
aplicaciones con este framework, y nosotros mismos escogemos su implementación. Da gusto mantener un
código limpio y estructurado con la seguridad que da la separación de microservicios y lo fácil que
es trabajar con los compañeros sobre el mismo proyecto.

Si eres usuario de Spring, estaremos encantados de que compartas con nosotros tus experiencias ya
sean positivas o negativas y así ampliar más la visión sobre el framework y ayudar a futuros
profesionales. ¡Déjanos tu opinión!


Spring Boot es el FRAMEWORK WEB más usado de JAVA. Utilizado por miles de empresas en grandes y complejas aplicaciones críticas

Por qué DEBES usar Spring Boot en tus proyectos JAVA - //Arteco

Ventajas de Spring Boot

Desplegar un programa con forma de Html dinámico realizado con Spring Boot y Java no puede ser más
fácil con Docker. A continuación los pasos a seguir

## Requisitos para desplegar una App Spring Boot con Docker

Obviamente para poder desplegar una aplicación de Java que incluye el framework Spring Boot
necesitarás tener las [herramientas de Java](https://www.arteco-consulting.com/post/instalar-java/)
instaladas de forma local. Aunque puede hacerse también con Gradle, recomendamos que uses
[Maven para empaquetar](https://www.arteco-consulting.com/post/instalacion-de-maven/) la web. Y por
último necesitarás tener
[instalado Docker](https://www.arteco-consulting.com/instalacion-de-docker/).

**Si no tienes ninguna aplicación hecha** revisa el
[inicio rápido con Spring Boot](https://www.arteco-consulting.com/post/tu-primera-aplicacion-con-spring-boot/).

## Preparar la aplicación de Spring Boot

El primer paso es asegurarnos de que la aplicación funciona correctamente al estar empaquetada en un
único **archivo jar**. Esto es fácilmente lograble si hemos usado
[Maven como herramienta de construcción de proyectos Java](https://www.arteco-consulting.com/post/tutorial-de-maven/)
asegurándonos de que hemos incluido el plugin siguiente en el fichero `pom.xml`

```
<project attr="...">
   
   <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
   </build>
</project>
```

Indicar la versión del plugin es opcional si nuestro proyecto tiene como `parent` el proyecto
paraguas de Spring Boot denominado `spring-boot-starter-parent`. Si no lo tienes puede incluir el
siguiente fragmento, normalmente al principio del fichero **pom.xml**, después de **project**:

```
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.4.RELEASE</version>
    <relativePath/>
</parent>
```

Habiendo realizado la configuración citada, el siguiente paso es invocar a Maven para verificar que
el bundle es correcto y contiene tanto nuestra aplicación compilada como las dependencias jars
contenidas dentro.

```
mvn clean package
java -jar target/app.jar
```

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

La aplicación debe arrancar correctamente, sin mostrar ningún aviso de error quedándose a la escucha
en el puerto Http indicado en la configuración, normalmente el 8080. De tal manera que al abrir el
navegador en la url **http://localhost:8080** se debe mostrar contenido de nuestro proyecto.

Llegados a este punto podemos asegurar que la aplicación funcionará desde dentro de un contenedor
gestionado por Docker.

## Construir la imagen de Spring Boot para Docker

Una vez comprobado que la aplicación en un fat-jar obtenido a través del proceso de empaquetado de
Maven, el siguiente paso es crear una imagen de la aplicación para que pueda ser usada en un
contenedor virtualizado. Para ello se debe crear el fichero `Dockerfile` con los pasos necesarios
para realizar el aprovisionamiento de la imagen. Afortunadamente, como usamos un fat-jar que
contiene todas las dependencias requeridas dentro de él el aprovisionamiento se reduce a simplemente
instalar la máquina virtual de Java.

De nuevo, el proceso es muy simple ya que partiremos de una imagen base que ya contiene el JDK que
necesitamos. Se mantienen actualizadas las imágenes base con todas las versiones activas del JDK.

Así, el fichero `Dockerfile` queda tan simple como:

```
FROM openjdk:8-alpine
ADD target/my-fat.jar /usr/share/app.jar
ENTRYPOINT ["/usr/bin/java", "-jar", "/usr/share/app.jar"]
```

La primera línea indica que queremos usar la versión JDK-8 sobre un
[sistema mínimo como Alpine Linux](https://alpinelinux.org/) para asegurarnos de que el tamaño del
archivo generado es lo más pequeño posible. La segunda línea añade nuestra aplicación al empaquetado
resultante, y por último se indica el comando de arranque que debe utilizar el contenedor una vez
inicializado.

Habiendo escrito el fichero de aprovisionamiento es hora de realizar la construcción de la imagen:

```
docker build -t my_docker_hub_username/my_image_name:my_image_version .
```

**Importante el punto (.) al final**, este indica el directorio actual, en donde está el fichero
Dockerfile. El argumento `-t user/image:tag` permite nombrar la imagen. Esta puede ser distribuida
públicamente mediante [Docker Hub](https://hub.docker.com/), o de forma privada a través de algún
[Registry como Harbor](https://goharbor.io/) privado como los disponibles en Amazon Web Services o
Google Compute Engine.

El comando de construcción generará una salida similar a la siguiente:

```
Sending build context to Docker daemon  86.11MB
Step 1/4 : FROM openjdk:8-alpine
8-alpine: Pulling from library/openjdk
e7c96db7181b: Pull complete
f910a506b6cb: Pull complete
c2274a1a0e27: Pull complete
Digest: sha256:94792824df2df33402f201713f932b58cb9de94a0cd524164a0f2283343547b3
Status: Downloaded newer image for openjdk:8-alpine
---> a3562aa0b991
fetch https://dl-cdn.alpinelinux.org/alpine/v3.9/main/x86_64/APKINDEX.tar.gz
fetch https://dl-cdn.alpinelinux.org/alpine/v3.9/community/x86_64/APKINDEX.tar.gz
Executing busybox-1.29.3-r10.trigger
OK: 123 MiB in 62 packages
Removing intermediate container 8c14d7443332
---> 0c3f73a47bff
Step 3/4 : ENTRYPOINT \["/usr/bin/java", "-jar", "/usr/share/app.jar"\]
---> Running in 0392060d1087
Removing intermediate container 0392060d1087
---> 23655b67c59f
Step 4/4 : ADD target/my-fat.jar /usr/share/app.jar
---> df132592b5f8
Successfully built df132592b5f8
```

La nueva imagen está disponible localmente y puede confirmarse con `docker images`

## Arrancar contenedor con Spring Boot

Ya tenemos todo lo necesario para arrancar nuestro contenedor que ejecute la imagen construida en el
paso anterior. Es importante saber que con cada nueva versión de la aplicación deberemos construir
de nuevo la imagen, ya que por norma general los contenedores deben ser autosuficientes. Todo lo que
necesiten deberá constar o estar aprovisionado en la imagen para asegurar que el entorno es estable
y reproducible aun usando los contenedores, entidades altamente volátiles.

Aunque las imágenes son estáticas, en el momento de arrancar un contenedor podemos hacerle llegar
parámetros en forma de variables de entorno o propiedades del sistema Java, usando
`-Dargument=value`. Muy útil para indicar el `profile` de Spring que queremos que se active en el
contenedor, por ejemplo para que use una u otra conexión con base de datos.

Aunque hay muchas formas, en nuestro caso usaremos una variable de entorno para indicar el perfil
activo en la aplicación. Esto debe hacerse indicando el nombre de perfil a usar en la variable de
entorno `SPRING_PROFILES_ACTIVE` tal y como indica la
[documentación oficial de Spring Boot](https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-profiles).

También se debe indicar qué puerto del contenedor debe estar abierto, para que las peticiones http
lleguen al proyecto. Por tanto, se debe añadir un argumento que configure que el tráfico que llegue
en un puerto local, se redirija al puerto 8080 (por defecto de Spring) del contenedor.

Dicho esto, ya sólo queda lanzar un contenedor usando la imagen anterior e indicando el perfil a
activar:

```
docker run -p 8080:8080 --env SPRING_PROFILES_ACTIVE=docker \
my_docker_hub_username/my_image_name:my_image_version
```

**Y listos!** Esta sentencia deja ejecutando un contenedor con nuestro nuevo proyecto del millón de
dólares ejecutándose en local. Esta misma configuración podrá servirte para desplegar la aplicación
en un entorno abierto en Internet, utilizando la plataforma de orquestación de contenedores
Kubernetes de Google, Amazon o Microsoft.

EJECUTA una aplicación desarrollada en Java con Spring Boot en la NUBE con Docker o Kubernetes de forma escalable en contenedores virtuales

Ejecutar SPRING BOOT en un CONTENEDOR Docker - //Arteco

Dockerizar con Spring Boot

React es la librería para la gestión de componentes visuales más usada en la creación de webs dinámicas por su  simplicidad y ecosistema

Aprende a programar con nuestras guías de iniciación

Aviso cookies

Este sitio usa cookies para revisar y monitorizar el comportamiento de usuarios mientras navegan por las diversas páginas.