<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Full Stack Java - Medium]]></title>
        <description><![CDATA[Desarrollo Backend y Frontend en Java, Spring Boot, Hibernate y Web - Medium]]></description>
        <link>https://medium.com/full-stack-java?source=rss----f2a1a2a057f---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Full Stack Java - Medium</title>
            <link>https://medium.com/full-stack-java?source=rss----f2a1a2a057f---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:34:31 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/full-stack-java" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fundamentos de MySQL — Parte I]]></title>
            <link>https://medium.com/full-stack-java/fundamentos-de-mysql-parte-i-f7206cd442c4?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/f7206cd442c4</guid>
            <category><![CDATA[mysql]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Mon, 10 Sep 2018 16:36:44 GMT</pubDate>
            <atom:updated>2018-09-10T16:36:43.660Z</atom:updated>
            <content:encoded><![CDATA[<h4>Comandos básicos</h4><p><em>MySQL </em>es un motor de base de datos basado en el lenguaje <em>SQL </em>(<em>Structured Query Language</em>) el cual consiste en almacenar datos mediante registros contenidos en tablas, las cuales están constituidas por columnas.</p><p>Conceptualmente una tabla es la forma en la que se modela una entidad mediante la definición de campos. Un campo es un eje de datos que contiene un nombre y tipo de datos, además de restricciones extras. Un campo equivale a una columna dentro de la tabla, por ejemplo, si queremos construir la tabla para almacenar registros de personas, entonces definiríamos la tabla con los siguientes campos: id int primary key auto_increment , nombre varchar(255) not null , edad int, rfc varchar(255). Observa que el campo id tiene asociado el tipo de dato int y las restricciones primary key y auto_increment. Una vez construida la tabla, podemos almacenar registros, los cuales son tuplas de datos con los valores para cada campo de la tabla, así por ejemplo (1, &#39;Ana&#39;, 23, &#39;ABCD1234&#39;) podría ser un registro de la tabla y contendría los valores para cada uno de los campos definidos.</p><h4>Instalación</h4><p>Vamos a partir de la instalación que es la parte más difícil. Lo primero será descargar el programa <em>MySQL Community Server</em> en su última versión.</p><p><a href="https://dev.mysql.com/downloads/windows/installer/8.0.html">MySQL :: Download MySQL Installer</a></p><p>Deberemos descargar la versión completa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8UDQqzreBwF2UjPdbnTZMg.png" /></figure><p>Para no registrar ninguna cuenta pulsa sobre el texto señalado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2qwkn7bjEJOLPfcfPl7AyA.png" /></figure><p>Usa la configuración por defecto excepto en este paso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*6Wx5YcH4JzDzqiW7mHBnlg.png" /></figure><blockquote>No olvides la contraseña solicitada para el usuario <em>root</em>.</blockquote><p>Una vez instalado deberíamos poder abrir el programa Workbench, el cual nos va a permitir ejecutar nuestros queries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/492/1*f8-i-WSgPDVfcnAkAuI5OA.png" /></figure><p>Crea una nueva conexión al usuario <em>root </em>y coloca tu contraseña.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/412/1*Ek0WumZi2peI_UBQSvYuVQ.png" /></figure><p>Una vez dentro de Workbench podremos ejecutar nuestros queries como se muestra abajo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/853/1*mfj-P3eFDK5qDF-FrR4fQw.png" /></figure><h4>Comandos básicos</h4><p>A continuación se deja una lista de comandos básicos para utilizarlos en la base de datos, presta mucha atención a los comentarios y la estructura de los <em>queries</em>. Observa atentamente que cada <em>query </em>finaliza en ; y a veces es mejor ponerlo en varias líneas para una mejor lectura.</p><blockquote>Query significa consulta en inglés, en adelante usaremos <em>query </em>para referirnos a cualquier instrucción <em>SQL </em>que enviemos a la base de datos.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f61897e57695ea4081142c02390a1c6d/href">https://medium.com/media/f61897e57695ea4081142c02390a1c6d/href</a></iframe><p>Ahora continua aprendiendo <em>MySQL </em>en <em>W3Schools</em> y resuelve los siguientes problemas.</p><p><a href="https://www.w3schools.com/sql/">W3Schools.com</a></p><blockquote><strong><em>Problema 1</em></strong><em>. Crear una base de datos llamada </em><em>super_cupcake.</em></blockquote><blockquote><strong><em>Problema 2</em></strong><em>. Definir la tabla </em><em>clientes con los campos que consideres.</em></blockquote><blockquote><strong><em>Problema 3</em></strong><em>. Definir la tabla </em><em>vendedores con los campos que consideres.</em></blockquote><blockquote><strong><em>Problema 4</em></strong><em>. Definir la tabla </em><em>cocineros con los campos que consideres.</em></blockquote><blockquote><strong><em>Problema 5</em></strong><em>. Definir la tabla </em><em>repartidores con los campos que consideres.</em></blockquote><blockquote><strong><em>Problema 6</em></strong><em>. Inserta al menos </em>tres <em>registros para cada tabla.</em></blockquote><blockquote><strong><em>Nota.</em></strong><em> Debes entregar los </em>queries <em>de cada problema.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f7206cd442c4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/fundamentos-de-mysql-parte-i-f7206cd442c4">Fundamentos de MySQL — Parte I</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamentos de Java — Parte IV]]></title>
            <link>https://medium.com/full-stack-java/fundamentos-de-java-parte-iii-4798e110d8f2?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/4798e110d8f2</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Fri, 07 Sep 2018 16:34:20 GMT</pubDate>
            <atom:updated>2018-09-07T16:35:02.448Z</atom:updated>
            <content:encoded><![CDATA[<h4>Clases y Objetos</h4><p>El concepto de <em>Clase</em> se refiere a abstaer un sistema, mecanismo o entidad mediante el modelado de <em>Artibutos</em> y <em>Métodos</em>. Cuando definimos una clase debemos pensar en cuáles son los atributos y métodos que van a representar una entidad. Los atributos se refieren a los elementos que describen al objeto, es decir, al estado interno de la entidad, por ejemplo, si tenemos una entidad <em>Persona</em> para un sistema de ventas quizás propongamos atributos como nombre, edad, peso, dirección, teléfono, etc. Sin embargo, si hablamos de la entidad <em>Persona</em> pero para un sistema gubernamental quizás propongamos atributos más descriptivos incluyendo su fecha de nacimiento, su CURP, su INE, estado civil, etc. Entonces los atributos de una entidad que serán modelados a través de la clase dependerán del tipo de sistema y lo que se desee almacenar. En cuánto a los métodos, nos referimos a un conjunto de funciones propios de la entidad que tienen acceso a los atributos del objeto. Piense por ejemplo, en una entidad llamada <em>Venta</em>, la cual tienen atributos propios de una venta en nuestro sistema como, fecha, monto, etc. Sin embargo, a dicha entidad además le queremos proporcionar funcionalidad como <em>registrar una venta</em>, <em>validar un monto</em>, <em>cancelar la venta</em>, etc. Esta funcionalidad se va a programar en la clase mediante métodos, y todas las instancias de la clase (los objetos) tendrán acceso a dicha funcionalidad, para realizar las tareas correspondientes sobre la entidad.</p><p>Vamos a ver un ejemplo de una clase definida para la entidad Robot, la cual posee atributos para ubicarse dentro de un plano 2D y métodos que le proporcionan la funcionalidad para desplazarse. Revisa bien los métodos y atributos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/728cf3af504bcb6d15eac38a9199f986/href">https://medium.com/media/728cf3af504bcb6d15eac38a9199f986/href</a></iframe><p>Observa que hemos declararo la clase Robot2D al igual que otras clases anteriores, sin embargo está clase no tiene punto de entrada (no es ejecutable). La clase define tres atributos double x, double y, y double a los cuales representan el estado interno del robot. Los atributos no fueron explícitamente asignados, por lo que su valor inicial será el valor por defecto de sus primitivos (cero doble 0d). Cuándo los atributos son primitivos, estos se inicializarán en el valor por defecto y cuando son complejos se inicializarán a null. También podemos ver que se han definido tres métodos public void avanzar(double d), public void girarIzquierda(double w) y public void girarDerecha(double w). Dichos métodos realizan la funcionalidad indicada en los comentarios, observa que accedemos a los atributos del objeto mediante this.x, this.y y this.a (se puede acceder sin this explícitamente, pero no es una buena práctica).</p><h4>Pruebas Unitarias y Clases Auto-Ejecutables</h4><p>Las clases que contienen un punto de entrada dónde se instancian a sí mismas para comprobar que su funcionalidad sea correcta se consideran <em>Clases Auto-Ejecutables</em>. Sin embargo, cuándo creamos otra clase que define el punto de entrada con funcionalidad para crear instancias de otras clases para comprobar su funcionalidad, entonces dichas clases se conocen como <em>Pruebas Unitarias</em>. Vamos a modificar la clase <em>Robot2D</em> para agregar un punto de entrada que realice pruebas unitarias mediante una instancia del robot e imprimiendo su posición después de aplicarle algunos giros y desplazamientos. Revisa el código cuidadósamente para predecir que valor se va a a imprimir y cómo antes de ejecutarlo en el <em>repl</em>. Nota que la clase <em>Main</em> funciona como <em>Prueba Unitaria</em> para la clase <em>Robot2D</em>.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Frepl.it%2F%40badillosoft%2FJava-Robot2D%3Flite%3Dtrue&amp;url=https%3A%2F%2Frepl.it%2F%40badillosoft%2FJava-Robot2D%3Flite%3Dtrue&amp;image=https%3A%2F%2Frepl.it%2Fpublic%2Fimages%2Freplit-logo-800x600.png&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=repl" width="800" height="600" frameborder="0" scrolling="no"><a href="https://medium.com/media/daaf5e90f34c1a5b0e08c354286edb7f/href">https://medium.com/media/daaf5e90f34c1a5b0e08c354286edb7f/href</a></iframe><p>Observa que en el repl hemos definido dos clases, la clase <em>Main</em> por defecto y la clase <em>Robot2D</em>. La clase Main tiene un punto de entrada dónde crea una instancia del robot mediante Robot2D robot = new Robot2D(), de esta forma se reserva un nuevo contexto de memoria en el <em>heap</em> para todo el espacio que necesite la clase (al menos lo de sus tres variables atributo). En este momento podemos advertir que <strong>un <em>Objeto</em> es una <em>Instancia</em> de una <em>Clase</em></strong>. Después se manda a ejecutar el método <em>avanzar</em> del objeto robot y se imprime el valor de sus atributos, desupés se llaman a otros métodos y se imprimen los resultados. Si se revisa correctamente la salida del programa se puede observar que se manda a avanzar al robot <em>10</em> pasos en dirección de su ángulo que inicialmente es cero, por lo que llegará a la posición <em>(10, 0)</em>, luego se girará al roboto a la izquierda (en el sentido contrario a las manecillas del reloj) <em>90 grados</em> o <em>Pi/2 radianes</em> y nuevamente avanzando <em>10</em> pasos, ahora llegando al punto <em>(10, 10)</em>, finalmente se gira al robot a la derecha (en el sentido de las manecillas del reloj) <em>90 grados</em> nuevamente y avanzando otros diez pasos llegando al punto final <em>(20, 10)</em>.</p><p>Ahora con el concepto de clase puedes empezar a modelar entidades y checar si su funcionalidad es correcta mediante pruebas unitarias. Resuelve los siguientes problemas para desarrollar tus habilidades de modelado.</p><blockquote><strong>Problema 1</strong>. Crear la clase <em>Persona</em> sólo con los atributos necesarios (considera los elementales).</blockquote><blockquote><strong>Problema 2</strong>. Crear la clase <em>Automóvil</em> con los atributos necesarios y un método llamado public void prender() que modifique un atributo llamado encendido a true.</blockquote><blockquote><strong>Problma 3</strong>. De la clase anterior modifica el método prender() para que mande un mensaje Trono socket porque ya está encendido si es que se manda a llamar al método prender cuando el atributo encendido es true.</blockquote><blockquote><strong>Problema 4</strong>. Crea una clase llamada Calculadora que no tenga atributos, sólo los métodos para hacer la suma, resta, multiplicación y división entre dos números. Los métodos tienen que devolver un double y recibir ambos operadores.</blockquote><blockquote><strong>Problema 5</strong>. Modifica la clase Robot2D para implementar los métodos public void cuadrado(double l) y public void pentagono(double l) los cuales deben hacer que el robot haga un recorrido en un cuadrado o pentágono de lado l e imprime cada vértice para comprobar que sea correcto (debe regresar al punto de inicio).</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4798e110d8f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/fundamentos-de-java-parte-iii-4798e110d8f2">Fundamentos de Java — Parte IV</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamentos de Java — Parte III]]></title>
            <link>https://medium.com/full-stack-java/fundamentos-de-java-parte-iii-77faf9df5502?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/77faf9df5502</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 16:07:28 GMT</pubDate>
            <atom:updated>2018-09-06T16:07:27.549Z</atom:updated>
            <content:encoded><![CDATA[<h4>Scanner y manejo de archivos</h4><p>La clase <em>java.util.Scanner</em> es muy útil para procesar flujos de datos llamados <em>Streams</em>, un flujo de datos es por ejemplo, la entrada y salida estándar que comunmente es el teclado y la terminal respectivamente, sin embargo los archivos también generan flujos de datos. La clase Scanner nos permite construir un objeto que trabaja directamente sobre el stream permitiendonos leer números, cadenas y bytes. Para crear una instancia debemos hacer Scanner sc = new Scanner(stream) donde sc es un nombre cualquiera para nuestro objeto Scanner y stream representa un flujo de datos de entrada como puede ser System.in (la entrada estándar o el teclado) o un <em>InputStream</em> en general como un <em>FileInputStream</em>. En el siguiente código podemos observar el uso de Scanner para leer dos números desde el teclaso y mostrar su suma en la pantalla.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5a975905d4bda41b741ec8353e3f3442/href">https://medium.com/media/5a975905d4bda41b741ec8353e3f3442/href</a></iframe><p>Observa que imprimimos un mensaje antes de leer el número y leemos el número mediante sc.nextInt(). Si quisieramos leer otros tipos de datos podemos usar nextFloat(), nextDouble() o nextLine() el último devuelve una cadena de texto de tipo <em>String</em>. No olvides importar el paquete import java.util.Scanner para que reconozca la clase.</p><h4>Abrir un archivo</h4><p>Para abrir un archivo utilizaremos la clase <em>FileInputStream</em>, la cual nos devuelve un <em>InputStream</em> que representa un flujo de datos de entrada que podemos utilizar con <em>Scanner</em>. El InputStream puede generar excepciones si no puede leer el archivo o problemas similares, por lo que deberemos hacer que nuestro método pueda fallar agregando throws IOException a nuestra declaración. En el siguiente ejemplo se muestra como abrir un archivo de texto plano llamado datos.txt el cual se supone es accesible desde nuestro programa (se encuentra en la misma ubicación o se escribe la ruta completa). Entonces lo primero que se hace es agregar la librería import java.io.FileInputStream, luego hay que marcar el método main como public static void main(String[] args) throws new IOException { ... } lo cual permitirá propagar la excepción (y evitar el uso de <em>try-catch</em>). Finalmente podemos recorrer <em>byte</em> por <em>byte</em> con un ciclo while usando in.read() para imprimir el byte en la terminal.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5e1401221a2eb59fb9eb81e4311e0922/href">https://medium.com/media/5e1401221a2eb59fb9eb81e4311e0922/href</a></iframe><p>Observa que se han importado java.io.FileInputStream y java.io.IOException, las cuales nos permiten utilizar las clases correspondientes, luego se ha marcado el método main con throws IOException para permitir propagar el error, entonces se crea la instancia in mediente FileInputStream y el nombre del archivo. Una vez abierto el flujo de datos procedemos a crear una variable b que va a retener cada byte leído, usando while ((b = in.read()) != -1) declaramos un ciclo while el cual va a repetir el bloque de código mientras la condición sea verdadera, en este caso la condición es “Asigna a <em>b</em> el siguiente byte leído del flujo de entrada <em>in</em>, luego comprueba si el byte es distinto de -1”. Entonces mientras el byte leído no sea -1, el programa va a imprimir el valor del byte y un espacio. Finalmente observa que cerramos el flujo antes de terminar con in.close().</p><h4>Abrir un archivo y leer sus datos con Scanner</h4><p>Leer los bytes de un archivo no es lo más útil para trabajar un archivo de números o texto. Por ejemplo, supongamos que tenemos el siguiente archivo de datos:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d51017cb80b1cdd9eb4ce30f820da197/href">https://medium.com/media/d51017cb80b1cdd9eb4ce30f820da197/href</a></iframe><p>En el archivo numeros.txt hemos colocado en la primer línea el número <em>5</em> y en la segunda línea hemos dispuesto 5 números separados por coma. Si quisieramos leer los valores podemos hacerloa través de un Scanner como se muestra en el ejemplo de abajo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0596b14cabded77f37d6a8566fbfed2c/href">https://medium.com/media/0596b14cabded77f37d6a8566fbfed2c/href</a></iframe><p>Observa que abrimos el flujo para el archivo numeros.txt, luego creamos un Scanner sobre el flujo, después leemos el primer número del flujo utilizando sc.nextInt(), este buscará el siguiente número y lo devolverá (en este caso el número <em>5</em>, es decir, <em>n</em> vale 5). Luego imprimimos la leyenda Leyendo 5 números (observa que se reemplaza <em>n</em>). Seguido, creamos un ciclo con <em>n</em> iteraciones (de <em>0 </em>a <em>n-1</em> hay <em>n</em> iteraciones), dentro del ciclo leemos el siguiente número en el flujo usando el Scanner, en la primera iteración será el <em>10</em>. Aquí puedes observar que no importa que los números estén en distintas líneas o separados por uno o varios espacios. Finalmente debemos cerrar el Scanner con sc.close() para que este se encargue de cerrar el archivo.</p><p>Con esto ya puedes manipular archivos de forma fácil, ahora debes profundizar tus conocimientos resolviendo los siguientes problemas.</p><blockquote><strong>Problema 1</strong>. Crear un programa que cuente el número de bytes en un archivo.</blockquote><blockquote><strong>Problema 2</strong>. Crear un programa que imprima cada byte invertido (255 menos el valor del byte).</blockquote><blockquote><strong>Problema 3</strong>. Modifica el archivo numeros.txt para poner 20 números en lugar de 5 (coloca 20 números que quieras).</blockquote><blockquote><strong>Problema 4</strong>. Modifica el programa anterior para que calcule la suma de los números.</blockquote><blockquote><strong>Problema 5</strong>. Modifica el programa anterior para que además calcule el promedio de los números.</blockquote><blockquote><strong>Problema 6</strong>. Modifica el programa anterior para que además muestre cuál es el número mayor.</blockquote><blockquote><strong>Problema 7</strong>. Modifica el programa anterior para que además muestre cuál es el número menor.</blockquote><blockquote><strong>Problema 8.</strong> Crea un archivo con al menos 5 líneas de texto y crea un programa que imprima línea por línea y su longitud. Hint. Utiliza el método sc.hasNextLine() para saber si hay una siguiente línea, sc.nextLine() para leer la siguiente línea y el ciclo while (sc.hasNextLine()) para que repita la lectura de la línea para cada línea del archivo. La longitud de una línea se obtiene con linea.length().</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77faf9df5502" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/fundamentos-de-java-parte-iii-77faf9df5502">Fundamentos de Java — Parte III</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a Java — Parte II]]></title>
            <link>https://medium.com/full-stack-java/introducci%C3%B3n-a-java-parte-ii-45eb1d669ee9?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/45eb1d669ee9</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Wed, 05 Sep 2018 15:59:00 GMT</pubDate>
            <atom:updated>2018-09-05T17:02:15.947Z</atom:updated>
            <content:encoded><![CDATA[<h4>Estructuras de Control if y for</h4><p>Todo lenguaje de programación debería incorporar una serie de estructuras para guiar el flujo del programa, como las <em>Condicionales</em>, las cuales nos permiten guiar el flujo del programa respecto a una condición o la selección en casos entorno al valor de una variable o los <em>Ciclos</em> los cuales nos permiten retener el flujo del programa repitiendo un bloque de código, ya sea de forma secuencial o basado en una condición. En esta sección veremos el uso de la estructura <em>if</em> y la estructura <em>for</em>, dejando otras estructuras para después.</p><h4><em>Estrucutra IF/ELSE IF/ELSE</em></h4><p>Una de las estructuras más usadas es la condicional <em>if</em>, la cual se utiliza para determinar si un bloque de código será ejecutado en base a una condición booleana, por ejemplo una comparación entre variables.</p><p>La estructura <em>if</em> puede anidar opcionalmente cualquier cantidad de subcondiciones <em>if-else</em> y también de forma opcional una y sóla una sentencia <em>else</em> al final de la misma. En el siguiente ejemplo se muestra una condición que determina si ejecutar una impresión dado el valor de la variable x, luego se muestra la misma estructura adicionando un bloque <em>else</em>, para finalmente mostrar un uso más amplio anidando varias condiciones del estilo <em>if-else</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d34746fda8e6bdf99bdf43b18a28305e/href">https://medium.com/media/d34746fda8e6bdf99bdf43b18a28305e/href</a></iframe><p>Observa que se declara una variable de tipo entero llamada x la cual es sometida a diversas condiciones, en caso de que se cumpla alguna condición sobre x se mostrará algún mensaje o no en la terminal. Prueba cambiar el valor de x para predecir que bloque de código se ejecutará.</p><p>Cuándo manejamos datos, será importante saber que tipo de dato esta asociado a nuestra variable, ya que si deseamos hacer una comparación entre cadenas no podremos hacerlo como con los números, incluso más adelante veremos como podemos comparar objetos complejos como <em>personas</em>, <em>empleados</em>, etc.</p><p>Los operadores básicos de comparación entre números son == que devuelve un booleano true si ambos valores son iguales, != devuelve true si ambos valores son diferentes, &gt; devuelve verdadero si el primer valor es mayor estricto (no incluye que sean iguales) y &gt;= devuelve verdadero si el primer valor es mayor o igual al segundo (por primero se refiere al de lado izquierdo y segundo al del lado derecho de la comparación, estos son operadores binarios). Del mismo modo operan &lt; y &lt;= haciendo la comparación de menor estricto y menor o igual respectivamente. También disponemos de operadores básicos lógicos como la conjunción (que se cumplan dos proposiciones booleanas) mejor conocido como el operador y o ^, que en Java queda definido por &amp;&amp;, así por ejemplo a &gt; b &amp;&amp; a &lt; c supondría comparar primero si a es mayor estricto a b y también que se cumpla que a sea menor estricto a c. La disyunción (que se cumpla cualquiera o ambas dos proposiciones booleanas) mejor conocido como el operador o o v, que en Java queda definido por || (doble<em> pipe</em> en inglés), así por ejemplo a &lt;= b || b &lt;= c significa que a sea menor igual a b o que b sea menor o igual a c. Finalmente la negación (que no se cumpla una proposición booleana) mejor conocida como no o ~, que en Java queda definido por ! (signo de exclamación que cierra), así por ejemplo !(a &gt; b) significa que si no se cumple que a es mayor a estricto a b la expresión es verdadera.</p><h4>Estructura FOR</h4><p>La estructura <em>for</em> es otra de las más utilizadas y sirve para repetir un ciclo de manera controlada en un proceso llamado iteración. La estructura <em>for</em> viene en dos variantes conocidas como el <em>for-tradicional</em> o sólo <em>for</em> y el <em>for-each</em> o sólo <em>foreach</em>. El ciclo <em>for</em> (<em>for-tradicional</em>) se basa en repetir un bloque de código basado en la inicialización, condición e incremento de una variable de control, dicha variable será conocida como el iterador (la variable iterador), la cual marcará el número de veces que deberá repetirse el ciclo. Por otro lado el ciclo <em>foreach</em> (<em>for-each</em>) se basa en repetir un bloque de código para cada elemento en una colección (o iterable) que puede ser un arreglo, una lista, etc.</p><p>En el siguiente ejemplo se muestra un programa usando la estructura <em>for</em> para calcular la suma de los primeros <em>100</em> números naturales, incluído el 100.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c55ef3af5c24cf493d645bf3da3c612/href">https://medium.com/media/7c55ef3af5c24cf493d645bf3da3c612/href</a></iframe><p>Observa que se declara la variable s de tipo entero la cual inicialmente es 0, luego se crea un ciclo for con la siguiente estructura inicialización; condición; incremento, lo cuál se refiere a que la estructura recibe tres sentencias, la primera es una sentencia de inicialización del <em>iterador</em>, generalmente int i; donde se declara la variable entera i que servirá de <em>iterador</em>, luego se declara la <em>condición de paro</em>, que finalizará el ciclo en caso de no cumplirse la condición, dicha condición generalmente se efectua sobre el <em>iterador</em>, finalmente se define una tercer sentencia con el incremento, después de que se ejecute el bloque de código se incrementará el iterador para generar una nueva evaluación a la condición, en este caso i++ significa i = i + 1 (a i se le asigna el valor que ya tenía más uno), también es equivalente i += 1. De esta forma el ciclo for puede leerse como: <em>Declara el iterador </em><em>i iniciado en uno, si </em><em>i es menor o igual a cien, entonces repite que </em><em>s sea lo que ya tenía más el valor de </em><em>i, en cada iteración incrementa a </em><em>i en uno y vuelve a evaluar la condición antes de repetir el siguiente ciclo, si la condición no se cumple salir del for.</em></p><p>La estructura foreach es un tanto distinta y su funcionalidad se basa en recorrer los elementos de un arreglo o colección (un iterable en general) sin importar el índice del mismo. En el ejemplo de abajo podemos observar la creación literal de un arreglo de números para luego ser iterados e impresos en la terminal.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2760ee85ab11386200af9d2be4920710/href">https://medium.com/media/2760ee85ab11386200af9d2be4920710/href</a></iframe><p>Observa que se declara numeros de tipo int[], esto significa que contendrá un arreglo de enteros, cuando utilizamos new int[20] le decimos al arreglo que tendrá <em>20</em> elementos indexados de <em>0</em> a <em>19</em>, sin embargo, en este caso le estamos diciendo que cree el arreglo de tamaño igual al literal {1, 2, 5, 7, 10, 12}, es decir, creará el arreglo con <em>6</em> lugares (índices del <em>0</em> al <em>5</em>) e inicializado en los valores 1, 2, 5, 7, 10 y 12. Podemos acceder a numeros[2] y nos devolvería el valor almacenado en el arreglo en la posición 2, es decir el elemento 5 (recuerda que empieza en el índice 0). Si no queremos usar el acceso mediante índices, podemos recorrer cada elemento mediante la estructura for, con la diferencia que ahora en lugar de enviar inicialización; condición; incremento desiganamos inicialización : iterable, donde inicialización se refiera a la declaración del iterador que va a estar iterando la colección o iterable y el iterable o colección que contiene elementos secuenciales que pueden ser recuperados uno a uno. Finalmente el for estructurado como foreach repite el ciclo para cada elemento iterado.</p><p>Aquí concluye la segunda parte de los fundamentos, ahora somos capaces de modificar el flujo del programa para resolver un montón de problemas. Resuelve cada uno de los siguientes problemas y discute en los comentarios tus dudas. Para crear códigos en Java sin instalar nada (la clase se llamará Main por defecto, puedes dejarla así) utiliza la página <a href="https://repl.it/">https://repl.it/</a></p><blockquote><strong>Problema 1</strong>. Crear un programa que solicite la edad de una persona e imprima si es mayor de edad el mensaje Ya puedes obtener tu credencial INE. Nota: no olvides imprimir un mensaje que diga Ingresa tu edad: antes de leer la edad.</blockquote><blockquote><strong>Problema 2</strong>. Crea un programa que calcule un número aletorio entre 0 y 1de tipo float y si es menor o igual a 0.5 imprimir Tendrás suerte hoy y si no imprimir quizás mañana sea tu día de suerte.</blockquote><blockquote><strong>Problema 3</strong>. Investiga que es el <em>Índice de Masa Corporal</em> (<em>IMC</em>). Crea un programa que solicite la estatura de la persona y su peso. Calcula el <em>Índice de Masa Corpotal</em> y mediante la estructura <em>if/if-else/else </em>determina en qué grado de obesidad se encuentra la persona, imprime mensajes del estilo Tu categoría es Delgado o Tu categoría es Obesidad Tipo I.</blockquote><blockquote><strong>Problema 4</strong>. Crear un programa que calcule la suma de los números naturales del <em>125</em> al <em>346</em>.</blockquote><blockquote><strong>Problema 5</strong>. Crea un programa que acumule los números múltiplos de <em>7</em> del <em>1</em> al <em>1000</em> mediante un iterador <em>for</em> y una condición <em>if</em> dentro del ciclo como i % 7 == 0 (investiga el operador módulo o residuo, cuando es cero significa que es un multiplo).</blockquote><blockquote><strong>Problema 6</strong>. Crea un programa que defina un arreglo de números enteros literal (por ejemplo int[] numeros = new int[] {1, 3, 5, 6, 8, 10, 11, 13, 14}) e iteralos mediante un <em>foreach</em> de tal forma que imprima si el número es <em>par</em> o <em>impar</em> (debe mostrar el número en cuestión). Hint: utiliza el operador módulo y haz n % 2 == 0 para saber si es <em>par</em>.</blockquote><blockquote><strong>Problema 7</strong>. Investiga como funciona la clase java.util.List y define una lista List&lt;Integer&gt; numeros y llenala con los primeros <em>100</em> números naturales al cuadrado. Después Imprime los valores de la lista utilizando un foreach como for (Integer n : numeros). Hint: utiliza un for de <em>1</em> <em>hasta100</em> (inclusive) y guarda en la lista i * i mediante numeros.add(i * i).</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45eb1d669ee9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/introducci%C3%B3n-a-java-parte-ii-45eb1d669ee9">Introducción a Java — Parte II</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducción a Java — Parte I]]></title>
            <link>https://medium.com/full-stack-java/introducci%C3%B3n-a-java-parte-i-9ef5320b634c?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/9ef5320b634c</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Sun, 02 Sep 2018 17:33:16 GMT</pubDate>
            <atom:updated>2018-09-02T23:53:40.130Z</atom:updated>
            <content:encoded><![CDATA[<h4>Variables y memoria</h4><p>Java es un lenguaje de programación portable a través de diversos Sistemas Operativos y Dispositivos, dado que su código se compila para una máquina virtual llamada JVM (Java Virtual Machine). Java es un lenguaje de programación Orientado a Objetos, lo cual nos permite programar sistemas complejos a tráves de clases y objetos. Además Java tiene un gran número de desarrolladores y librerías, por lo que puede ser utilizado para diversos fines, como crear aplicaciones de escritorio, servicios web, programas de administración y mucho más.</p><p>En esta serie de entregas analizaremos a fondo las partes más importantes de Java para tener un panorama general del lenguaje y poder ampliar los conocimientos de forma autodidacta.</p><h4>Puntos de entrada o Clases Ejecutables</h4><p>En Java la metodología de trabajo es a través de Clases o Interfaces, por lo que para definir un archivo, deberemos llamarlo igual que el nombre de su Clase o Interfaz definida, por ejemplo, si queremos crear un programa ejecutable que muestre el mensaje hola mundo en la terminal, entonces, deberemos crear una clase llamada HolaMundo o con algún nombre que se desee y está deberá estar contenida dentro del archivo llamado exactamente igual que la clase más la extensión .java, es decir, el archivo se deberá llamar HolaMundo.java.</p><p>Para poder ejecutar el archivo, este deberá contener una clase y dentro de la clase deberemos definir un <em>Punto de Entrada,</em> el cual se refiere a un método especial llamado public static void main(String[] args), exactamente así. Dicho método especial es estático, esto significa que el método no tiene acceso a las propiedades definidas en la clase, es decir, este método es independiente de la clase y sólo podrá acceder a otras propiedades o métodos estáticos. El método main también es especial porque es ejecutado automáticamente por Java cuando se manda a llamar en modo ejecución, en resumen tenemos:</p><blockquote>Una Clase de Java puede ser ejecutada desde una terminal, si y sólo si se ha definido un método especial public static void main(String[] args). Dicho método main será ejecutado y tódo su código contenido será evaluado.</blockquote><p>Veamos entonces, un ejemplo de la clase llamada HolaMundo, contenida en el archivo de texto plano HolaMundo.java, que despliega el mensaje Hola Java en la terminal y finaliza.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb160446b83ffe4c0a0ee9a90cf6e0d7/href">https://medium.com/media/eb160446b83ffe4c0a0ee9a90cf6e0d7/href</a></iframe><p>Como podemos observar en el código anterior, hemos definido una clase llamada HolaMundo, la cual posee un <em>Punto de Entrada</em> (un método especial public static void main(String[] args)). Dentro del método main podemos observar la sentencia System.out.println(&quot;Hola Java&quot;), la cual imprime en la salida estándar System.out el texto Hola Java, dicha salida estándar es generalmente la terminal.</p><h4>Variables y Memoria</h4><p>Las variables nos permiten acceder a los datos almacenados en la memoria y existen dos tipo de variables, las primitivas, que son almacenadas en la <em>Memoria Stack</em> y las variables complejas, que son almacenadas en la <em>Memoria Heap</em>.</p><p>Las variables primitivas pueden almacenar datos simples, por ejemplo, números enteros o decimales, caracteres y <em>bytes</em>. Los tipos de datos asociados a las variables primitivas son int, float, double, char, byte, entre otros. Las variables primitivas retienen valores absolutos mediante la Memoria Stack, la cuál se encarga de reservar memoria para cada tipo de dato según los bytes que requiera, por ejemplo, para un entero descrito en 32 bits, debería reservar 4 bytes (<em>1 byte equivale a 8 bits</em>). En la memoria stack, cada valor accedido genera una copia, por lo que asignar una variable primitiva a otra equivale a crear una nueva variable con una copia del valor de la otra variable, a esto se le llama <strong>copia por valor</strong>. Puedes consultar la documentación para más detalles: <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html</a></p><p>Las variables complejas son creadas a partir de instanciar una clase en un objeto. Una clase es una construcción de atributos y métodos como veremos adelante. Cuando una clase es instanciada, se refiere a que el programa solicita un nuevo espacio en memoria para almacenar todos los atributos de la clase, dicho espacio será único para cada instancia, por ejemplo, si la clase require almacenar dos números enteros, entonces cada instancia solicitará la memoria necesaria para almacenar dos números enteros (8 bytes). Entonces cada instancia reserva su propia memoria, pero dicha memoria reservada es compleja, dado que en cualquier momento podrían generarse nuevas instancias y el programa debe asignar rápidamente memoria de tamaño variable, por lo que se crea el concepto de <em>Memoria Heap</em>, la cual consiste en una región extensa de memoria, la cual está asignado la memoria para cada instancia y de tamaño variable, de este modo, cada que una instancia solicita memoria, se busca una región disponible en el <em>heap</em> y se le asigna. La desventaja es que hay un tiempo de asignación que al cabo de un rato afecta el rendimiento del programa, por lo que Java implementa un recolector de basura encargado de liberar la memoria para las instancias que ya no tienen referencia (una referencia a la instancia hace que la memoria siga viva). Cuando copiamos una variable compleja (desde ahora instancia) a otra variable compleja, no se crea una copia de la memoria, sino que simplemente ambas variables se refieren a la misma memoria y lo que le pase a una variable le pasa a la otra, esto se conoce como <strong>copia por referencia</strong>. Para ver más de este tema puedes ver el siguiente video: <a href="https://youtu.be/_y7k_0edvuY">https://youtu.be/_y7k_0edvuY</a></p><p>Una convensión de los programadores Java es nombrar con mayúsculas las clases, y cada clase genera un tipo de dato personalizado, por lo que si te encuentras una variable cuyo tipo de dato comience por mayúscula, automáticamente debes saber que se trata de un tipo de dato complejo y las variables serán complejas, por ejemplo, si creamos la variable String mensaje; o Persona persona.</p><p>Vamos a ver un ejemplo de un programa que utiliza variables primitivas para calcular el siguiente número entero.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/01fb9a93678213b0d96d69c9ca9eb742/href">https://medium.com/media/01fb9a93678213b0d96d69c9ca9eb742/href</a></iframe><p>Ahora vamos a comparlo con un programa que utiliza variables complejas y sus implicaciones.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c99dada6bdce43c0f146a1182a6979a/href">https://medium.com/media/2c99dada6bdce43c0f146a1182a6979a/href</a></iframe><p>Podemos ver que cuando utilizamos variables primitivas, estas crearán copias de sus valores cuando sean enviadas a otros métodos o asignadas a otras variables. Sin embargo, cuándo utilicemos variables complejas (variables de clase), estarémos copiando la referencia a la memoria que le fue asignada a la instancia referente, por lo que si pasamos la variable a tráves de un método o la asignamos a otra variable, en realidad estaremos enviando la dirección de memoria del heap dónde se encuantran los datos del objeto, por lo que todas las variables referenciadas podrían ser modificadas. Para más detalles puedes visitar: <a href="https://www.geeksforgeeks.org/variables-in-java/">https://www.geeksforgeeks.org/variables-in-java/</a></p><blockquote>Las variables primitivas son puertas de acceso a los datos almacenados en la <em>memoria stack</em>, por convención iniciarán con minúscula como int, float, double, etc. Cuándo copiamos una variable primitiva en otra, se creará una copia de su valor en memoria. Las variables complejas igualmente son accesos a instancias almacenadas en la <em>memoria heap</em>, las cuales fueron previamente asignadas por el operador new y por convención comienzan con mayúsculas, cada clase genera un tipo de dato complejo, por ejemplo, String, Integer, Float, Double, Persona, etc. Cuándo copiamos una variable compleja en otra, se copiará la referncia a la memoria dónde se almacena la instancia, por lo que ambos objetos estarán trabajando sobre la misma instancia y se afectarán entre sí.</blockquote><p>Con esto concluimos está primer entrega que nos permite ver que la programación en Java parte de clases, dichas clases al poseer un método especial se pueden ejecutar. También hemos podido entender el concepto de variables y ahora somos capaces de almacenar datos en nuestro programa, tanto datos primitivos como complejos.</p><p>Ahora deberías poder resolver los siguientes ejercicios sin problemas.</p><blockquote><strong>Problema 1</strong>. Crear una clase llamada Suma la cuál contenga un punto de entrada main, crear dos variables de tipo int llamadas a y b inicializada con dos números que se desee, imprimir la suma de a y b.</blockquote><blockquote><strong>Problema 2</strong>. Crear un programa (una clase con punto de entrada) que defina una variable de tipo String inicializada en Hola mundo de Java e imprimir la longitud de la variable utilizando el método length().</blockquote><blockquote><strong>Problema 3</strong>. Investiga cómo funciona la clase Scanner del paquete java.util para leer un número entero desde el teclado. Hint: utiliza Scanner sc = new Scanner(System.in) y sc.nextInt(). Agrega las excepciones necesarias.</blockquote><blockquote><strong>Problema 4</strong>. Utiliza la clase Scanner para leer una cadena de texto.</blockquote><blockquote><strong>Problema 5</strong>. Crea un programa que lea dos números enteros desde el teclado e imprima la suma de ellos. Nota: imprime antes un mensaje para que el usuario sepa que se están esperando los números.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ef5320b634c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/introducci%C3%B3n-a-java-parte-i-9ef5320b634c">Introducción a Java — Parte I</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modelar un Negocio en Spring Boot y Hibernate — Parte III]]></title>
            <link>https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-iii-109b298a7d73?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/109b298a7d73</guid>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[business-intelligence]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 17:17:40 GMT</pubDate>
            <atom:updated>2018-08-28T17:17:40.230Z</atom:updated>
            <content:encoded><![CDATA[<h4>La capa de servicios</h4><p>En las entregas anterioes hemos visto la <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-i-a8978d72e413">Capa de Datos</a> y la <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-ii-67c59640cd07">Capa de Acceso a Datos</a>, las cuales nos permiten definir las entidades de nuestro sistema y el consumo desde una base de datos con Hibernate. Ahora toca el tema de la Capa de Servicios la cual se refiere a la capa donde se definen todas las tareas que es capaz de realizar nuestro sistema. Esta es una de las capas más importantes ya que aquí se realizarán todas las operaciones de validación de datos y seguridad.</p><p>Podemos pensar que todo negocio puede dividirse en un conjunto de tareas que es capaz de realizar, cada tarea ofrece por sí mismo un servicio. Una tarea puede definirse como un conjunto de transacciones y operaciones lógicas para llevar al sistema de un punto A a un punto B. El interactor principal de cada tarea deberá ser una entidad principal a la que se le aplique la tarea, auque podría darse el caso de tener dos o tres entidades como entrada de la tarea.</p><p>Un servicio está representado por una clase marcada con la anotación Service la cual contendrá métodos funcionales, cada método representará una tarea.</p><p>Los servicios más sencillos son aquellos que se encargan simplemente de consumir un repositorio, a estos servicios les llamaremos <em>Servicios de Integridad</em> (del Repositorio), ya que su único objetivo es consumir correctamente los repositorios, estos servicios serán los más aburridos y fastidiosos de programar porque al principio nos dará la sensación de estar replicando código y preguntarnos el por qué no cosumimos directamente el repositorio (no lo hagan, es importante el servicio cómo capa intermedia entre las capas superiores y la capa de acceso a datos).</p><p>A los servicios dedicados a realizar operaciones específicas para el flujo del negocio les llamaremos <em>Servicios de Operabilidad</em> (del Negocio), ya que estos servicios guiarán el flujo del negocio y su operabilidad, un ejemplo de estos servicios son los que se dedican a realizar las operaciones necesarias para completar una transacción compleja como en el caso de realizar una venta, almacenar un pedido y generar un reporte, almacenar un archivo y generar enlaces estáticos, etc.</p><p>Finalmente a los servicios dedicados a realizar operaciones de segurida serán llamados <em>Servicios de Seguridad</em> y los encargados de generar reportes y estadísiticas serán los <em>Servicios de Gestión</em>.</p><h4>Definir un Servicio</h4><p>Para crear un servicio basta con definir una clase marcada con la anotación Service y ubicada en el paquete com.miempresa.service para mejor organización. En el ejemplo siguiente, veremos un servicio dedicado a consumir el servicio para nuestra entidad Cupcake, por lo tanto llamaremos a este servicio CupcakeService.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*sMRcjYmxXjzyBNHqDfa6-g.png" /></figure><p>Observa que hemos creado la clase CupcakeService marcada con la anotación Service, dicha clase posee un <em>AutoEnlace</em> al repositorio CupcakeRepository. La anotación Autowired le indica a Spring que esta clase debería tener acceso a la instancia que se haya creado para CupcakeRepository, en este momento Spring buscará la instancia del repositorio y la conectará automáticamente a nuestra clase de servicio, permitiendonos ejecutar los métodos implementados como findAll, findByNombre y costoMaroyA. También observa que cada método realiza un simple consumo al repositorio, por lo que podemos intuir que este es un Servicio de Integridad, que realiza algunas validaciones antes de consumir al repositorio, para que sea seguro consumirlo. Finalmente podemos observar que los últimos dos métodos generar error de tipo Exception si la condición sobre los parámetros recibidos lo indica, por ejemplo, si se intentan buscar los Cupcakes cuyo costo es mayor a un número negativo (quizás no se permita para no manejar números negativos por error), entonces se producirá un error avisando que el costo debe ser mayor a cero. Quizás esta validación es absurda, pero ya en un negocio real puede salvar la integridad del sistema y hay que tener cuidado con cada consumo que se haga al repositorio para no exponer datos sensibles.</p><p>Más adelante profundizaremos sobre los otros tipos de servicios para implementar servicios de seguridad y generación de reportes.</p><h4>Conclusiones</h4><p>La Capa de Servicios es la encargada de proveer seguridad a nuestro sistema para consumir las capas inferiores correctamente, lo ideal será que la capa de servicios consuma la capa de acceso a datos y realice las validaciones necesarias antes de consumir la capa DAO para proteger la integridad del sistema.</p><p>La capa de servicios consiste en crear clases marcadas con la anotación Service para definir métodos que consuman la capa de acceso a datos o realicen operaciones sobre nuestro sistemas.</p><p>Una buena práctica es dividir nuestro negocio en tareas para poder crear servicios que resulevan las tareas de nuestro negocio, por ejemplo, si tenemos un negocio de venta de productos en línea vamos a tener tareas como, registrar un cliente, verificar que un cliente tenga tal correo y contraseña, registrar un producto, buscar productos, realizar un proceso de venta, marcar que el usuario compró tales productos en tal fecha, etc.</p><p>La capa de servicios es fundamental para el negocio y representa la parte más fuerte de él ya que si queremos migrar el negocio, bastará con revisar cada una de las tareas que realiza y cómo las realiza.</p><p>Envía tus comentarios sobre las dudas que tengas sobre esta capa para ampliar está entrega y no olvides visitar la siguiente capa llamada la Capa del API. ¡Hasta la próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=109b298a7d73" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-iii-109b298a7d73">Modelar un Negocio en Spring Boot y Hibernate — Parte III</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modelar un Negocio en Spring Boot y Hibernate — Parte II]]></title>
            <link>https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-ii-67c59640cd07?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/67c59640cd07</guid>
            <category><![CDATA[mvc]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[business-intelligence]]></category>
            <category><![CDATA[dao]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 16:32:18 GMT</pubDate>
            <atom:updated>2018-08-28T17:18:22.463Z</atom:updated>
            <content:encoded><![CDATA[<h4>La capa de acceso a datos</h4><p>En nuestra entrega anterior revisamos la <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-i-a8978d72e413">Capa de datos</a>, la cual consiste en definir las entidades de nuestro negocio y su relación a la base de datos mediante Hibernate. Ahora es momento de revisar la segunda capa llamada la Capa de Acceso a Datos o DAO (Data Access Object).</p><p>Esta capa se enfoca en brindar el acceso a los datos almacenados en la base de datos y entregarlos como las clases POJO definidas en la capa de datos. El mecanismo para realizar esto será crear una interfaz derivada de CrudRepository la cual proveerá métodos ya autoprogramados para realizar consultas a la base de datos y la cuál podremos extender con nuestras propias consultas personalizadas.</p><p>La capa DAO será en sí una instancia creada y administrada por Hibernate, con la cuál podremos consumir la base de datos mediante el concepto de <strong><em>Repositorio</em></strong>.</p><h4>Definir la interfaz del repositorio</h4><p>Un repositorio es un sistema que administra el almacenamiento y recuperación de datos en un sistema. Para reducir la complejidad es bueno utilizar un repositorio por cada <em>Entidad</em> definida en nuestro sistema. Así por ejemplo si tenemos la entidad <em>Cliente</em>, deberemos definir su repositorio <em>ClienteRepository</em> o <em>ClienteDAO</em>.</p><p>Lo primero será crear el paquete com.miempresa.dao donde almacenaremos todas las interfaces (repositorios). Dentro de este paquete crearemos interfaces como en la capa de datos DTO creabamos clases definiendo las entidades. Para que la interfaz funcione como un repositorio debemos marcar la interfaz con la anotación Transactional de javax.transaction.* y extender la interfaz genérica CrudRepository&lt;T, S&gt; donde T es la clase POJO del DTO de la entidad a trabajar y S es el tipo de dato para el campo marcado como <em>ID</em> que generalmente es <em>Integer</em> o <em>Long</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YcU-6wzzQ4q17KEZWq1u4Q.png" /></figure><p>Observa que la interfaz llamada CupcakeRepository ha sido marcada con la anotación Transactional y que extiende (deriva) de CrudRepository&lt;Cupcake, Integer&gt;, esto significa que nuestro repositorio tiene acceso a la entidad Cupcake y que además puede ya realizar búsquedas genéricas en la base de datos tales como findAll() =&gt; Iterable&lt;Cupcake&gt;, findById(Integer id) =&gt; Optional&lt;Cupcake&gt;, save(Cupcake cupcake), etc. Los métodos genéricos que provee por defecto un <em>CrudRepository</em> se generan automáticamente ya que se sabe a que tabla será mapeada la entidad, cuál es el tipo de dato de su <em>ID</em> y qué campos contiene.</p><h4>Definir un Query personalizado en el Repositorio</h4><p>Muchas veces no bastarán los métodos genéricos provistos como findAll o findById, por lo que podemos definir nuestras propias consultas SQL fácilmente.</p><p>Existe una convensión que dice que si llamamos a nuestra consulta findByX entonces se creará automáticamente el query que haga la busqueda para el campo X y sólo deberemos definir el método de consumo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*dseiOeni2M95GuaEj3JKwg.png" /></figure><p>En el ejemplo anterior podemos observar que se define el método findByNombre que recibe String nombre. De está forma Hibernate puede intuir bajo la convención findBy… que nos referimos al query select * from cupcakes where nombre=:nombre enviando el parámetro nombre como reemplazo para :nombre. La consulta anterior nos devolverá una entidad de tipo Cupcake ya que eso nos devuelve la base de datos, así que podemos devolver Optional&lt;Cupcake&gt; o simplemente Cupcake, la diferencia es que Optional&lt;Cupcake&gt; nos devuelve un objeto al que podremos preguntarle si existe y Cupcake nos devolvería null en caso de que no se devuelvan resultados.</p><p>Si queremos realizar una consulta que no cumpla la convesión anterior, por ejemplo, un método llamado costoMayorA(Float costo) que devuelva una lista iterable de Cupcakes cuyo campo costo sea mayor a pasado como parámetro, entonces deberemos establecer el query select * from cupcakes where costo &gt; :costo, en temas siguientes profundizaremos más este tema para lograr realizar queries de tipo <em>join</em> y más complicados.</p><p>Entonces definimos el query mediante la anotación Query y en el método solicitamos los parámetros de reemplazo para el query como se muestra a continuación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*qmdde5eR4zqUud4K4Rj3JQ.png" /></figure><p>Observa que en la anotación Query definimos el parámetro value con la consulta específica y el parámetro nativeQuery=true para especificar que es un query nativo del dialecto (en este caso MySQL). También hay que notar que dentro del query tenemos :costo el cuál será reemplazado con el indicado en costoMayorA(Float costo).</p><h4>Conclusiones</h4><p>La capa de Acceso a Datos mejor conocida como DAO, nos permite definir métodos para consumir nuestra base de datos de forma fácil, no sólo podemos definir consultas de tipo SELECT, también podemos definir queries de tipo INSERT, UPDATE, DELETE, etc. En entregas futuras profundizaremos otra vez sobre esta capa para realizar consultas avanzadas.</p><p>La capa DAO consiste en interfaces marcadas con la anotación Transactional y derivan de CrudRepository&lt;T, S&gt; con la cual Hibernate puede implementar toda la funcionalidad correspondiente para que las consultas definidas en cada método funcionen. Esto nos ahorra bastante tiempo al momento de trabajar las consultas a nuestra base de datos y hace que tengamos un sistema que no se pierde en código (anteriormente deberíamos definir la conexión a la base de datos, crear statements, preparar los statements y ejecutar los statements).</p><p>La capa DAO debe ser consumida singularmente por los servicios para garantizar la seguridad de nuestro sistema, no deberíamos permitir que un controlador REST consuma directamente nuestra capa DAO al menos que los datos no sean sensibles y no requieran seguridad.</p><p>Envía tus comentarios sobre las dudas que tengas sobre esta capa para ampliar está entrega y no olvides visitar la siguiente capa llamada la <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-iii-109b298a7d73">Capa de Servicios</a>. ¡Hasta la próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67c59640cd07" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-ii-67c59640cd07">Modelar un Negocio en Spring Boot y Hibernate — Parte II</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modelar un Negocio en Spring Boot y Hibernate — Parte I]]></title>
            <link>https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-i-a8978d72e413?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/a8978d72e413</guid>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[business-intelligence]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 05:05:37 GMT</pubDate>
            <atom:updated>2018-08-28T16:33:03.563Z</atom:updated>
            <content:encoded><![CDATA[<h4>La capa de datos</h4><p>Al modelar un negocio debemos tomar en cuenta cinco capas importantes que nos van a ayudar a organizar correctamente nuestro proyecto. Estas capas nos van a permitir ubicar rápidamente las entidades que realizan una función específica en nuestro sistema, como definir las estructuras de datos, realizar consultas a la base de datos, proveer métodos seguros para validar los datos antes de enviarlos a la base de datos, proveer un acceso a los servicios a tráves de un API REST y consumir nuestros datos mediante interfaces WEB. Cada una de las funciones descritas anteriormente corresponde a una de las Capas de Negocio que revisaremos a continuación a lo largo de estas entregas.</p><h4>Capa de Datos</h4><p>La primer capa se refiere a los datos en nuestro sistema, es decir, la representación de las entidades a nivel código. En la capa de datos estaremos modelando entidades DTO (Data Transactional Object), las cuales nos ayudarán a transportar los datos en las transacciones entre el sistema, la base de datos y los clientes web.</p><h4>Definición de la Clase POJO</h4><p>En esta capa se deben especificar clases POJO (Plain-Old Java Object) las cuales son clases simples que se componen de atributos, getters, setters y posiblemente constructores, pero en ningún momento implementan métodos funcionales. Las clases POJO nos permiten retener datos de entidades y poder transportarlas fácilmente (son fáciles de serializar/deserializar).</p><p>Veamos un ejemplo de la clase Cupcake la cual retiene la información necesaria de un Cupcake para un negocio de venta de pastelillos en línea.</p><p>Lo primero será crear un paquete llamado com.miempresa.dto en dicho paquete vamos a guardar todas nuestras clases POJO referentes a la capa de datos. En el siguiente código podemos observar a la clase Cupcake.java definida con los atributos id, nombre y costo con los tipos de datos Integer, String y Float. Observa que utilizamos Integer en lugar de int y Float en lugar de float, esto es así para permitir retener el valor que provenga de una base de datos y también valores nulos (null).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*wE4GBun6574-TENsXLMAtw.png" /></figure><blockquote>Importante: No olvides crear el paquete <em>com.miempresa.dto</em> ya que sin este tu código va a quedar desorganizado y tus clases revueltas, además si no escribes bien el nombre del paquete, Spring Boot no será capaz de encontrar tus clases al momento de aplicar las anotaciones.</blockquote><p>Finalmente debemos recordar que podemos generar todos los <em>getters</em> y <em>setters</em> automáticamente dando clic secundario y luego en Source&gt;Generate Getters and Setters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/649/1*H4FXSFv0IGtXvq8yqKrHFA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/552/1*t-yZuGd277tZbTEHkiHdEQ.png" /></figure><p>El resultado será una clase POJO con sus atributos, getters y setters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/1*BzCBQziwWdfdUlNHfqxBmw.png" /></figure><h4>Convertir una Clase POJO en una Entidad de Hibernate</h4><p>Las clases POJO definidas como antes nos permiten retener la información de una entidad, en el ejemplo anterior, la información de un cupcake o panque. Sin embargo, si queremos expresar una relación entre un Cupcake de nuestra base de datos y un Cupcake de nuestro sistema, podemos utilizar las anotaciones de Hibernate, para indicarle a nuestra clase POJO que puede ser mapeada directamente a una tabla con los mismos atributos y nombres.</p><blockquote>Hibernate utiliza una convención de nombres la cual indica una estrategia para establecer la relación entre el nombre en nuestra clase y el nombre en la base de datos, por ejemplo, si en la base de datos tenemos la tabla persona_puesto será mapeada a la clase PersonaPuesto, si tenemos el campo fecha_nacimiento será mapeada al atributo fechaNacimiento.</blockquote><p>Lo primero que debemos hacer añadir la anotación Entity a nivel clase junto a la anotación Table(name=&quot;cupcakes&quot;). Esto le permitirá a Hibernate mapear nuestra clase POJO a una tabla cupcakes de MySQL, si no existe la crea y si ya existe la utiliza. Observa que importamos javax.persistence.* para poder utilizar la anotación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*4DCGaEM8g5RicQBNJrGE-A.png" /></figure><blockquote>Una anotación es un marcado que se le aplica a una Clase, Atributo, Método o Parámetro de un Método para poder modificar y extender su funcionalidad rápidamente. Previo a las anotaciones, teníamos que definir extensos archivos XML dónde se indicaba la configuración especial. Ahora simplemente marcamos los elementos con anotaciones y podemos disponer de la configuración automática que proveen los frameworks como Spring y Hibernate.</blockquote><p>Lo siguiente es establecer cuál será el campo que funcione como <em>ID</em> para nuestra entidad. En este caso será id, por lo cual marcaremos dicho campo con la anotación Id igualmente de javax.persistence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/298/1*xPLL9GXHK26LG2iy0PJIkg.png" /></figure><p>Ahora si ejecutamos nuestro proyecto, veremos que Hibernate ejecuta el query create table cupcakes ... para crear la tabla cupcakes porque no existia, en futuras ejecuciones ya no ejecutará esta consulta ya que la tabla ya existirá.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*ML9LrnZ8pcKp8JQTNvbv9w.png" /></figure><h4>Conclusiones</h4><p>La capa de datos mejor conocida como DTO nos permite definir las entidades del sistema mediante clases POJO marcadas con las anotaciones Entity, Table y Id para establecer una relación entre una entidad de nuestro sistema y una tabla de la base de datos.</p><p>Toda entidad en nuestro negocio debería tener una tabla en nuestra base de datos y viceversa, toda tabla en nuestra base de datos, debería tener una entidad en nuestro proyecto. Esto es una buena práctica para conocer todos los entes que residen en nuestro sistema y poder interactuar a nivel código con cada uno de ellos. Más adelante hablaremos sobre el correcto modelado de tablas en MySQL para detectar las entidades fuertes y débiles y sus relaciones.</p><p>Todas los componentes para la Capa de Datos deberían ser Clases POJO marcadas con Entity dentro del paquete com.miempresa.dto. Es importante comprender la relación directa entre una tabla de nuestra base de datos y una entidad en nuestro sistema.</p><p>Las entidades o DTOs sirven para transmitir datos en nuestro sistema mediante transacciones que acarren nuestras entidades de una operación a otra sin perder la integridad entre los datos.</p><p>Otra buena práctica es marcar las clases con el sufijo DTO para recordar su significado, así la clase Cupcake quedaría como CupcakeDTO.</p><p>Envía tus comentarios sobre las dudas que tengas sobre esta capa para ampliar está entrega y no olvides visitar la siguiente capa llamada la <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-ii-67c59640cd07">Capa de Acceso a Datos</a>. ¡Hasta la próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8978d72e413" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-i-a8978d72e413">Modelar un Negocio en Spring Boot y Hibernate — Parte I</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configurar un proyecto con Spring Boot y Hibernate]]></title>
            <link>https://medium.com/full-stack-java/configurar-un-proyecto-con-spring-boot-y-hibernate-5893125888cf?source=rss----f2a1a2a057f---4</link>
            <guid isPermaLink="false">https://medium.com/p/5893125888cf</guid>
            <category><![CDATA[maven]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[mvc]]></category>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Alan Badillo Salas]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 03:58:27 GMT</pubDate>
            <atom:updated>2018-08-28T15:38:12.702Z</atom:updated>
            <content:encoded><![CDATA[<h4>Crear un proyecto nuevo en Spring Boot y conectar MySQL con Hibernate</h4><p>Vamos a configurar un nuevo proyecto con Spring Boot y Hibernate. Spring Boot es un framework disponible a través de repositorios Maven y Gradle con el cual podemos ofrecer Servicios Web con Java. A diferencia del Spring tradicional Spring Boot nos permite una rápida configuración a través de anotaciones @ las cuales nos permiten ahorrar mucho código y semántica XML. Por otro lado Hibernate es un framework para poder mapear nuestra base de datos con el código a tráves de entidades POJO (Plain-Old Java Object o clases sencillas que contienen sólo atributos, propiedades y constructores sin funcionalidad extra). Hibernate nos permite consumir nuestras tablas SQL a través de entidades y repositorios o crear dichas tablas si no existen a través de nuestras entidades.</p><h4>Instalación</h4><p>Lo más sencillo es descargar el entorno de desarrollo llamado Spring Tools Suite o STS desde la página: <a href="https://spring.io/tools">https://spring.io/tools</a></p><p>En Windows es importante descargar la versión de 64 bits para no tener problemas ya que en la página nos descarga por defecto la versión de 32 bits y al abrir arroja un error. El enlace directo a la versión de windows de 64 bits es: <a href="https://download.springsource.com/release/STS/3.9.5.RELEASE/dist/e4.8/spring-tool-suite-3.9.5.RELEASE-e4.8.0-win32-x86_64.zip">https://download.springsource.com/release/STS/3.9.5.RELEASE/dist/e4.8/spring-tool-suite-3.9.5.RELEASE-e4.8.0-win32-x86_64.zip</a></p><p>En Windows y Linux bastará con descomprimir el archivo Zip descargado y ejecutar el programa ubicado en la carpeta RELEASE. En mac hay que copiar el ejecutable a la carpeta de aplicaciones.</p><p>El editor STS está basado en Eclipse y preconfigurado para crear rápidamente proyectos de Maven y de Spring.</p><p>Es importante tener instalado Java JRE 8+, Java JDK 8+ y MySQL Cummunity Server 5+. Desde la página de Oracle podemos descargarlos aceptando la licencia y pulsando en No thanks, just download para no tener que registrarse.</p><p>Al instalar MySQL verfica que se agregue al PATH en windows y puedas acceder a este desde la terminal, más adelante dejaré un enlace que contenga los pasos de la instalación aquí.</p><h4>Crear el proyecto de Spring Boot</h4><p>Spring es un framework cuyo objetivo es facilitar la implementación de las capas de un negocio (ver más abajo) con Java. Spring Boot se basa en la creación de clases que estén marcadas con anotaciones especiales que guien el desarrollo de nuestro proyecto. Para empezar, debemos crear un proyecto limpio dónde poner nuestro código.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g6avtvDDBHeAAVTgFyE4NQ.png" /></figure><p>Vamos a pulsar el ícono de nuevo proyecto luego en la opción de <em>Spring Boot</em> y en <em>Spring Starter Project</em> o en File&gt;New&gt;Spring Starter Project. Como se muestra en la siguiente imagen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*LLPxPjM18A-FfvtoQ3aP0Q.png" /></figure><p>En la primer pantalla de configuración deberemos establecer el nombre del proyecto (A), el cuál debe estar relacionado con lo que estemos haciendo, este también será utilizado como nombre del Artefacto, el cual se refiere al nombre clave del proyecto para nuestra empresa. También estableceremos el nombre del grupo de desarrollo (B) que se refiere al grupo de desarrollo, comunmente se usa el nombre de la empresa de la forma com.miempresa u org.miempresa, es buena práctica repetir este mismo nombre como nombre del paquete principal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/594/1*lKsbmhSQRRMWfTDqgt7GPA.png" /></figure><p>En la siguiente ventana de configuración deberemos marcar las dependencias de nuestro proyecto. Si queremos usar MVC con Web será bueno marcar desde este momento Web&gt;Web, si vamos a utilizar Hibernate con MySQL podríamos marcar desde este momento SQL&gt;MySQL, SQL&gt;JDBC y SQL&gt;JPA. La finalidad de marcar estas dependencias es cargar las librerías JAR necesarias para utilizar diferentes tecnologías, algo así como indicar que librerías queremos utilizar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*ZEF7HMMZGr32Aw2Bs4kwiQ.png" /></figure><p>Si por error olvidaste agregar una dependencia o quieres agregar más dependencias puedes hacerlo en el archivo pom.xml ubicado en la raíz (A) del proyecto. Para añadir una dependencia basta con conocer el nombre del grupo y artefacto. En la pestaña señalada en (B) podemos acceder a un buscador de dependencias.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s_p1A8JTL6oBFpom1ZrsIg.png" /></figure><blockquote>Maven es un sistema de administración de dependencias que se encarga de descargar las librerías necesarias para que el proyecto funcione, se basa en la creación de un árbol de dependencias el cuál marca para cada dependencia que otras dependencias (librerías) necesita y en qué versión mínimo. Si alguna dependencia falta, Maven automáticamente la descargará de internet y actualizará el árbol. Con esto evitamos estar buscando y agregando librerías manualmente, sin embargo, será imposible crear proyectos sin acceso a internet. Pero podemos utilizar la página <a href="https://start.spring.io/">https://start.spring.io/</a> para generar un proyecto y descargarlo como Zip para comenzarlo a utilizar.</blockquote><h4>Configurar Hibernate</h4><p>Hibernate es un framework especializado para las primeras dos capas del negocio (a saber la capa de datos DTO y la capa de acceso a los datos DAO). Hibernate funciona mediante el marcado de clases mediante anotaciones para relizar un mapeo entre nuestras entidades POJO en Java y nuestras tablas en SQL. Lo primero será modificar el archivo de propiedades (application.properties (A) ubicado en la carpeta src/main/resources) de la aplicación para indicar las siguientes configuraciones que se muestran comentadas en la imagen. También deberemos cambiar el nombre de la base de datos (B) y posiblemente el puerto o servidor de MySQL y el nombre del usuario y contraseña (C).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*Hq_8em_nZOxPtZpjoCH6ZA.png" /></figure><p>En este caso se ejecutará el query select 1 para verificar que la conexión a la base de datos este funcionando y la demás configuración puede quedar igual.</p><h4>Ejecutar el proyecto</h4><p>Antes de ejecutar el proyecto sería recomendable acceder a MySQL desde una terminal con el comando mysql -u root -p (A) sustituyendo root si es necesario por el nombre de usuario con el que tenga acceso. También deberíamos garantizar que la base de datos super_cupcake exista usando el comando create database if not exits super_cupcake;(B).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*rUFYKFs2AnHT7oSmcM4sCA.png" /></figure><p>Para ejecutar el proyecto deberemos estar ubicados sobre cualquier archivo de src/main/java o el archivo de propiedades y pulsando el botón verde (A) o en Run&gt;Run. Al ejecutar por primera vez deberemos seleccionar Spring Boot App del menú. Esto montará a través de Apache Tomcat un servidor en el puerto por defecto 8080 (puede modificarse en las propiedades con server.port = 5000 para usar otro puerto).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/1*kWuRm8eapLndiWi2reKQiw.png" /></figure><p>En la consola deberíamos ver algo similar a la imagen. Observa que el botón de Stop (A) debería estar activo para poder detener el servidor, sino significa que hay algún error. También observa el puerto dónde fue montado el servidor (B) por defecto el 8080.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_8dHfP5UyhjchljC3hvWYg.png" /></figure><p>Si accedemos a la ruta http://localhost:8080 en el navegador, veremos una página genérica de Spring que nos indica que no se ha definido ningún mapeo para la ruta /.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/603/1*uhLdg-nRWI33VCz2_RtG_Q.png" /></figure><p>Si detenemos el servidor y actulizamos la ruta en el navegador obtendremos un error ya que ahora no hay nada en ese puerto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*Uw7GVGGiY_QWVIHdsMK24g.png" /></figure><h4>Conclusiones</h4><p>Hasta el momento hemos configurado nuestro primer proyecto de Spring Boot y Hibernate listo para albergar todo el backend y frontend de nuestro negocio. Ahora ya puedes acceder a la serie de entregas para <a href="https://medium.com/full-stack-java/modelar-un-negocio-en-spring-boot-y-hibernate-parte-i-a8978d72e413">Modelar un Negocio</a> y comenzar a trabajar tus proyectos.</p><p>Desde ahora podemos darnos cuenta lo fácil y rápido que es configurar un proyecto en Spring Boot gracias al gestor de dependencias Maven y el archvio application.properties. Y aunque aún no hay código bailando podemos estar orgullosos de poder montar un servidor en escasos minutos.</p><p>Si te ha gustado esta entrega no olvides aplaudirla y suscribirte. ¡Hasta la próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5893125888cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/full-stack-java/configurar-un-proyecto-con-spring-boot-y-hibernate-5893125888cf">Configurar un proyecto con Spring Boot y Hibernate</a> was originally published in <a href="https://medium.com/full-stack-java">Full Stack Java</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>