Ir al contenido principal

Instalando Apache NetBeans 10 y configurarlo con Jakarta EE

Pruebas Unitarias a JPA y servicios REST con Arquillian + Payara. (4/4) - Empaquetando el Servicio

Ya hemos desarrollado el servicio, con acceso a base de datos, lógica de negocio, lo hemos probado tanto a nivel de EJB de base de datos, como probando el servicio REST.

Ahora nos toca empaquetarlo todo en un solo .jar para poderlo ejecutar como servicio autónomo.



Conexión a la base de datos

Hasta ahorita la conexión a la base de datos era ficticia. Bueno, era una conexión real, pero la base de datos y el contenido era falso, porque eran para las pruebas funcionales.

Ahora nos toca crear la verdadera conexión a base de datos para producción.

Crearemos la base de datos, y para este ejemplo, usaremos MySQL, con los siguientes valores:

  • Base de datos: store
  • Usuario: store
  • Contraseña: store
Listo. Seguimos con realizar la conexión a la base de datos. Como estamos bajo el estándar de Java EE Jakarta EE, utilizaremos un DataSource para que la conexión lo gestione el servidor que es Payara Micro. Crearemos el archivo web.xml y colocaremos el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <data-source>
        <name>java:app/store</name>
        <class-name>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</class-name>
        <url>jdbc:mysql://localhost/store</url>
        <user>store</user>
        <password>store</password>
    </data-source>
</web-app>


Notemos que esta declaración es la estándar. No necesitamos configurar la conexión (ni el pool ni el recurso) en el Payara Micro, porque no tendremos una línea de comandos (ni menos una consola web) para crear la conexión. Aunque hay maneras de crearlas al ejecutar el microservicio, pero por ahora nos bastará con realizar la conexión desde el archivo web.xml. No faltará uno que diga: pero la conexión debería ser parametrizada por un archivo externo... sí, tienes razón, pero eso lo veremos en otro momento.

Unidad de persistencia

Hasta ahora, la unidad de persistencia creada era únicamente para las pruebas, no existe nada real hasta ahora. Así que, crearemos el archivo persistence.xml con el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence              http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
  <persistence-unit name="storePU" transaction-type="JTA">
    <jta-data-source>java:app/store</jta-data-source>
    <shared-cache-mode>ALL</shared-cache-mode>
    <properties>
      <property name="hibernate.hbm2ddl.auto" value="update"/>
      <property name="javax.persistence.schema-generation.database.action" value="create"/>
    </properties>
  </persistence-unit>
</persistence>



Debemos remarcar lo siguiente:
  1. La línea 3 debe mantener el mismo nombre de la unidad (storePU) que nuestra unidad para pruebas, ya que nuestros EJB utilizan ese mismo nombre de unidad.
  2. La línea 4 es la conexión a la base de datos creada en el archivo web.xml, tal cual.


El perfil para distribuir

He trabajado con maneras más complejas para crear el archivo resultante, pero en este ejemplo dejaré lo más básico posible con tal de generar nuestro microservicio ejecutable.

Para ello, necesitamos crear un perfil en el pom.xml llamado dist de tal manera que al ejecutar el maven con ese perfil, se prepare el archivo .jar con todo lo necesario para ejecutarse.

Este perfil también debe contar con la biblioteca de la base de datos, en este caso, de MySQL.

Además, el log debería ser simple, no al detalle como lo es el modo debug. Ya no necesitaríamos el Log4j.
    <profiles>
        <profile>
            <id>dist</id>

<!-- aqui pondremos lo demas -->
        </profile>
    </profiles>


Dependencias

Las dependencias para este perfil son como sigue: MySQL y slf4j-simple

    <profiles>
        <profile>
            <id>dist</id>
            <dependencies>
                <dependency>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-simple</artifactId>
                    <version>1.7.25</version>
                </dependency>
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.45</version>
                </dependency>

            </dependencies>


La creación del empaquetado y del Uber jar

Aquí es donde se empaqueta todo, se prepara el uber jar con todo el .war generado y metido con el mismo Payara Micro:

            <build>
                <plugins>
                    <!-- Copy project dependency -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-dependency-plugin</artifactId>
                        <version>3.0.2</version>
                        <executions>
                            <execution>
                                <id>copy-payara-micro</id>
                                <goals>
                                    <goal>copy</goal>
                                </goals>
                                <configuration>
                                    <outputDirectory>target</outputDirectory>
                                    <stripVersion>true</stripVersion>
                                    <silent>true</silent>
                                    <artifactItems>
                                        <artifactItem>
                                            <groupId>fish.payara.extras</groupId>
                                            <artifactId>payara-micro</artifactId>
                                            <type>jar</type>
                                        </artifactItem>
                                    </artifactItems>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <version>1.6.0</version>
                        <dependencies>
                            <dependency>
                                <groupId>fish.payara.extras</groupId>
                                <artifactId>payara-micro</artifactId>
                                <version>${payara.version}</version>
                            </dependency>
                        </dependencies>
                        <executions>


                            <execution>
                                <id>payara-uber-jar</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>exec</goal>
                                </goals>
                                <configuration>
                                    <executable>java</executable>
                                    <arguments>
                                        <argument>-jar</argument>
                                        <argument>target/payara-micro.jar</argument>
                                        <argument>--port</argument>
                                        <argument>9595</argument>
                                        <argument>--logo</argument>
                                        <argument>--nocluster</argument>
                                        <argument>--deploy</argument>
                                        <argument>${basedir}/target/${project.build.finalName}.war</argument>
                                        <argument>--outputuberjar</argument>
                                        <argument>${basedir}/target/${project.build.finalName}.jar</argument>
                                    </arguments>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>


Para más detalle de este archivo de configuración, lo puedes revisar en la sección final del post Ejemplos de Microservicios con Java.

Creamos el archivo .jar

Listo!. crearemos el paquete con el siguiente comando desde la consola.


mvn clean package -P dist


El comando pasará por las etapas de construcción, prueba y empaquetado.


Ejecución del microservicio.

Ya tenemos el jar. Solo nos bastará con ejecutarlo como un .jar cualquiera. Como se generó en la carpeta target, entraremos allí y ejecutamos:

target target
java -jar payara-arquillian-1.0.jar


Y vemos que se ejecute:


 Incluso, podemos revisar si el servicio se ha conectado a la base de datos utilizando el pool de conexiones. Podemos revisar esto en el MySQL:


Invocando al servicio

Nos aseguramos de que la base de datos tenga la información necesaria. Yo generé data con https://www.mockaroo.com/ Lo recomiendo.

Pues bien, ahora invocamos el servicio (yo lo haré usando httpie) y este es el resultado.


Código fuente


El código fuente de la aplicación para este tutorial está disponible aquí

https://bitbucket.org/apuntesdejava/payara-arquillian/src

Comentarios

Entradas más populares de este blog

RESTful... la forma más ligera de hacer WebServices (Parte 1)

Quienes hayan usado SOAP para WebService, sabrán que es bien fácil de diseñar, pero algo complicado de consumir: se necesita toda una API para construir los clientes utilizando el WSDL. Por ejemplo, para PHP se necesita de la biblioteca NuSOAP. Entonces, para lograr el concepto de "lenguaje único XML" es un dolor de cabeza. Y más aún si el cliente es tan simple como JavaScript, manejar XML de SOAP provocaría suicidos masivos... o no usar WebServices.

Además, con SOAP se permite crear un solo servicio y ponerle varios métodos. Esto puede llevar a un mal diseño del servicio ya que podría tener un servicio que haga de todo: por ejemplo, un servicio de manejo de Clientes que permita también manejar Proveedores.

RESTful es una propuesta muy interesante de Roy Fielding que permite manejar los servicios web con métodos definidos, manteniendo la simpleza del protocolo como XML, pero que cada servicio sea identificado únicamente con un solo URI.

En este post veremos cómo crear un Ser…

¿Por valor o por referencia?

Esta es una pregunta existencial para todo programador Java. Cada uno encuentra una respuesta satisfactoria. Pero ahora veremos, basándonos en el libro para Certificación SCJP 1.5 de Katty Sierra, sobre la respuesta correcta.

Contraseñas encriptadas con Java

¿Quién no ha querido encriptar texto o archivo? Hay diversas maneras para hacer eso, por ejemplo, utilizando un diccionario donde se reemplazara cada caracter por un código.. y para poder desencriptarlo se debería utilizar el mismo diccionario para revertir el proceso. Pero si el diccionario cae en manos de alguien que no queremos que lo sepa, entonces estamos en peligro.
Cuando yo programaba en pascal, mi encriptación favorita era invirtiendo los bits... pero cualquiera también puede invertir los bits y listo.
Pero ya gente experta logró algoritmos de encriptación populares. Los más conocidos: MD5 y SHA.
En este post hablaremos cómo encriptar texto, sobretodo las contraseñas, utilizando MD5 o SHA.