Stuck in the sound - Pursuit

Esta es una ocasión especial.... Llevaba tiempo buscando la letra de una canción que no parecía estar en la red. Entonces recibí ayuda y finalmente di con ella. La canción es "Pursuit", de un grupo francés llamado "Stuck in the sound".

Run Away from the underworld
Just don't look back and hold my hand
We're joining the underground...
Embracing the cause of the Lonely

We'll be always on the run We'll be always on the run Will somebady spread the word Somewhere there is a ship for the sad ones. But when the lights hit the ground Will everybody be safe in the shadow We'll be always on the run We'll be always on the run

Baby the world seems to be fake
When I'm without you and I
Will set you on fire.
We'll never go back
We left behind the doubt
Decide to live without a sound
Oh we gotta go

...

Agregando código a un proyecto git existente

Hola!

Hablar sobre git se ha vuelto algo ya del diario en el mundo de la programación, entonces hacer un tutorial sería ya algo trillado.

Por ende, de lo que vamos a platicar es cómo inicializar un repositorio de git.

Imaginemos el escenario donde acabamos de crear un proyecto en github. Para iniciar la magia, deberíamos clonar el proyecto a nuestra computadora, situarnos en el directorio y listo. Empezar el código.

Pero, ¿qué pasa cuando ya tenemos un proyecto y queremos "vincularlo"?. Por ejemplo, estaba creando un proyecto de laravel mediante composer. Entonces, ¿debería copiar y pegar todo?, ¡para nada!.

Primero, hay que posicionarnos en la raiz del proyecto, digamos "cd laravel" y seguimos los siguientes pasos:

• git init
• git remote add origin https://github.com/dazamar01/laravel.git 
• git add .
• git commit -m 'Primer commit'
• git push -u origin master

Y listo. Con esto hemos apuntado nuestro código al repositorio donde queremos administrar el proyecto.

La línea mas completa es la de "git remote add origin", sin embargo lo único que deberías hacer es reemplazar la url por la de tu proyecto git.

Por cierto, mi repositorio es https://github.com/dazamar01, por si necesitas mas códigos.

Espero te sea de utilidad ;)

Código fuente React-Java

Hola,

En esta ocasión voy a ser un poco mas breve que en otras ocasiones, ya que me he visto envuelto en varios proyectos.

Dándole continuidad al proyecto de migración entre vb6 y java, les comento que he estado trabajando también con React.js (si, esa librería de fb).

Así que les comparto el código para trabajar el backend y el front end. Es decir, con esto pueden iniciar.

Back end:
https://github.com/dazamar01/react-backend-java

Front end:
https://github.com/dazamar01/react-frontend

Estoy siendo súmamente breve porque pronto quiero hacer otra versión de estos dos proyectos, y en ese entonces, voy a hacer un nuevo post.


Espero te sea de utilidad ;)

Implementación de Consultas dinámicas en JPA

Hola.

Últimamente he estado trabajando en una migración de un sistema desde Visual Basic 6 (si, de cuando los perros se amarraban con longanizas) a Java 8.

Pensé que todo iría bien hasta que me tocó enfrentarme a las consultas con parámetros dinámicos. En este caso, se utiliza al Entity Manager y las Criteria Querys.

Y como soy de pocas palabras y mas acciones, dejo a continuación, el código con los imports necesarios para efectuar un método, traer un resultset paginado, el count del total de registros, generar los criterias y efectuar la lista de parámetros a manera de módulo separado para ahorrar trabajo.

import java.time.LocalDate;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Logger;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import javax.persistence.TypedQuery;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

@Service("controlFechaOrdeniaServiceImpl")

@Transactional

public class ControlFechaOrdeniaServiceImpl implements ControlFechaOrdeniaService {

    private final static Logger LOGGER = Logger.getLogger("");

    @PersistenceContext

    private EntityManager entityManager;

    @Autowired

    @Qualifier("controlFechaOrdeniaRepository")

    private ControlFechaOrdeniaRepository controlFechaOrdeniaRepository;

    private CriteriaBuilder criteriaBuilder;

    @Override

    public ControlFechaOrdeniaVO buscar(Integer paginaActual, Integer activos) throws Exception {

        ControlFechaOrdeniaVO controlFechaOrdenia = new ControlFechaOrdeniaVO();

        ControlFechaOrdenia filtro = new ControlFechaOrdenia();

        List<ControlFechaOrdenia> listaControlFechaOrdenia = null;

        controlFechaOrdenia.iniciarPaginador(paginaActual);

        if (activos != null) {

            filtro.setActivo(activos);

        }

        try {

            criteriaBuilder = entityManager.getCriteriaBuilder();

            listaControlFechaOrdenia = getRegistros(controlFechaOrdenia.getDesde(), filtro);

            controlFechaOrdenia.setListaControlOrdenia(listaControlFechaOrdenia);

            long totalRegistros = getCantidadRegistros(filtro);

            controlFechaOrdenia.setPaginado(totalRegistros);

            listaControlFechaOrdenia.stream().forEach(item -> { LOGGER.log(Constantes.LOG_LEVEL_INFO, "Id: "

            + item.getId()); });

            

        } catch (Exception ex) {

            LOGGER.log(Constantes.LOG_LEVEL_ERROR, "ControlFechaOrdeniaImpl.buscar");

            LOGGER.log(Constantes.LOG_LEVEL_ERROR, ex.getMessage());

        }

        return controlFechaOrdenia;

    }

    private List<ControlFechaOrdenia> getRegistros(int desde, ControlFechaOrdenia filtro) {

        

        List<Predicate> predicates = new ArrayList<Predicate>();

        List<ControlFechaOrdenia> listaControlFechaOrdenia = new ArrayList<>();

        TypedQuery<ControlFechaOrdenia> typedQuery;

        

        try {

            

            final CriteriaQuery<ControlFechaOrdenia> criteriaQuery = criteriaBuilder

                    .createQuery(ControlFechaOrdenia.class);

            final Root<ControlFechaOrdenia> entityRoot = criteriaQuery.from(ControlFechaOrdenia.class);

            predicates = this.getPredicateList(entityRoot, criteriaBuilder, filtro);

            

            criteriaQuery.orderBy(criteriaBuilder.asc(entityRoot.get("id")));

            criteriaQuery.where(criteriaBuilder.and(predicates.toArray(new Predicate[0])));

            typedQuery = entityManager.createQuery(criteriaQuery);

            typedQuery.setFirstResult(desde);

            typedQuery.setMaxResults(Constantes.REGISTROS_POR_PAGINA);

            listaControlFechaOrdenia = typedQuery.getResultList();

            return listaControlFechaOrdenia;

            

        } catch (Exception ex) {

            throw ex;

        }

    }

    public long getCantidadRegistros(ControlFechaOrdenia filtro) {

        List<Predicate> predicates = new ArrayList<Predicate>();

        try {

            final CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);

            Root<ControlFechaOrdenia> entityRoot = criteriaQuery.from(ControlFechaOrdenia.class);

            criteriaQuery.select(criteriaBuilder.count(entityRoot));

            predicates = this.getPredicateList(entityRoot, criteriaBuilder, filtro);

            

            criteriaQuery.where(predicates.toArray(new Predicate[predicates.size()]));

            TypedQuery<Long> typedQuery = entityManager.createQuery(criteriaQuery);

            return typedQuery.getSingleResult();

        } catch (Exception ex) {

            throw ex;

        }

    }

    private List<Predicate> getPredicateList(Root<ControlFechaOrdenia> entityRoot, CriteriaBuilder criteriaBuilder, ControlFechaOrdenia filtro) {

        List<Predicate> predicates = new ArrayList<Predicate>();

        if (filtro.getActivo() != null) {

            Predicate predicateFilter = criteriaBuilder.equal(entityRoot.get("activo"), filtro.getActivo());

            predicates.add(predicateFilter);

        }

        return predicates;

    }

}

Espero te sea de utilidad ;)

Suscripción gratuita a Pluralsight

Hola!

Estaba buscando entre opciones para aprender una tecnología y mientras estaba investigando, un amigo me comentó lo siguiente.

Me dió la opción de registrarse en uno de los sitios de Microsft Dev y, mediante esto, obtener entre otros beneficios, de 3 meses gratis de acceso a Pluralsight.

Lo que tienen que hacer es:

1.       Registrarse gratuitamente al programa “Visual Studio Dev Essentials” en el siguiente enlace:
https://www.visualstudio.com/en-us/products/visual-studio-dev-essentials-vs.aspx

2.       Luego de crear su cuenta verán en la página principal la oferta “Pluralsight 3-month subscription”, denle click al enlace “Get code” y llenen el formulario que les pedirá algunos datos básicos.

En enlace original lo pueden consultar acá

Yo ya tengo mi suscripción activa y funcionando.

Espero te sea de utilidad ;)

Instalación y puesta en Marcha de Ruby on Rails

Hola!

Hace algo de tiempo que no estoy por aquí, sin embargo, hace unos días, me encargaron adentrarme en el mundo de Ruby on Rails y tuve que efectuar las configuraciones necesarias para dejarlo a punto en Windows, por lo que me pareció buena idea compartirlo con ustedes. Por tanto, basta de misterio y ¡a por ello!

Paso 1: Descarga del software necesario.

En primer lugar, será necesario descargar el instalador de Ruby On Rails desde la página de Rails Installer (http://railsinstaller.org/en). Al momento de esta instalación, se descargó la versión 2.2 (figura 1). Comprende los siguientes complementos:

• Ruby 2.2.6
• Rails 5.0
• Bundler
• Git
• Sqlite
• TinyTDS
• SQL Server Support
• DevKit

Figura 1. Descarga de Ruby

Teniendo lista la descarga, es necesario descargar la consola de git desde la página oficial (https://git-scm.com/), esto con el objetivo de ejecutar de una manera práctica los comandos necesarios de Ruby. Es posible descargarla directamente desde aquí.

Paso 2: Instalación de los componentes:

Continuando con el proceso, es necesario ejecutar el instalador de ruby previamente descargado:

Figura 2. Inicio de instalación de Ruby

Se debe aceptar las licencias y presionar “siguiente”, en la siguiente ventana, será necesario que las opciones para instalar Git y añadir los ejecutables se encuentren marcados (Figura 3).

Figura 3. Se deben marcar ambas casillas

Figura 4. Proceso de instalación

Al terminar la instalación (Figura 5), es recomendable iniciar la configuración de la consola de git y ssh.

Figura 5. Seleccionar la configuración de git

Al configurar git, solicitará el nombre de usuario y un correo electrónico (figura 6).

Figura 6. Configurando git

Al finalizar el proceso, la consola proporcionará una clave de seguridad. Es altamente recomendable almacenarla en algún archivo para su posterior uso.

Este proceso instalará también git, por lo que no es necesario instalar el que se descargó. Esta indicación se dio en el caso de que la instalación fallara o se omitiera algún paso de los indicados.

Para verificar que la instalación se efectuó satisfactoriamente, se deberá abrir la consola de git y escribiendo el comando “Rails -v”, el cual retornará la versión de Ruby instalada en el sistema. Si muestra un mensaje similar al de la figura 7, entonces se ha concluido satisfactoriamente el proceso.

Figura 7. Comprobar la versión de Ruby

Paso 3: Generación del CRUD “Person”

Para este proceso, se tomará como base de datos MySQL y se utilizará la base de datos “persontest”. El código de creación es el siguiente:

CREATE DATABASE persontest /*!40100 COLLATE 'utf8_spanish_ci' */;

use persontest;

Habiendo creado la base de datos, es necesario abrir la cosola de git y situarse en el directorio “c/Sites”, el cual se crea por defecto cuando se instala Ruby.

Es necesario ejecutar el comando “rails new persontest”: esta instrucción generará todos los archivos necesarios para el proyecto (Figura 8).

Figura 8. Construir el proyecto

Al finalizar el proceso, debe aparecer una ventana similar a la de la figura 9.

Figura 9. Construcción del proyecto finalizada

El proyecto se ha generado en c:\Sites\persontest, esta carpeta se puede abrir con cualquier editor de texto, para este caso se utilizará sublime text 3.

Llegados a este paso, es necesario configurar la gema de MySQL junto con la opción de SQLite para testing, en el archivo “Gemfile” ubicado en raíz del proyecto (figura 10) y la conexión a la base de datos en el archivo “config/dabatase.yml” (figura 11).

Figura 10. Configuración de gema para MySQL

Figura 11. Configuración de conexión a MySQL

Es necesario, una vez hechas estas configuraciones, decirle a Rails que debe descargar e instalar las librerías que se le indicaron. Esto se logra ejecutando los comandos “bundle update” y “bundle install”. Al finalizar debe mostrarse algo similar a la figura 12.

Figura 12. Se ha ejecutado bundle update y bundle install

A continuación, se procederá a generar el “scaffold” (se le llama scaffold al proceso de construcción de código necesario para una funcionalidad simple) de la clase persona, con los atributos mencionados al principio (figura 13).

El comando a ejecutar es: rails generate scaffold person firstName:string lastName:string

Figura 13. Generación de Scaffold

Ejecutado el proceso anterior, es necesario llevar a cabo el proceso de “migrado”, es decir, indicarle a Rails que debe conectarse a la base de datos y construir el modelo indicado. Esto se logra con el comando: rails db:migrate (figura 14).

Figura 14. Ejecución del migrado

Lo anterior generará la tabla “people” en la base de datos (véase CoC Ruby para mayor entendimiento) y se mostrará algo similar a la figura 15.

Figura 15. Generación satisfactoria del modelo en la base de datos

Paso 4: Arrancar el servidor y ver el módulo en acción

Lo primero a seguir es arrancar el servidor, esto se logra ubicándose en la carpeta generada por ruby (C:\Sites\persontest) y ejecutando el comando “rails s”. Es recomendable otorgar los permisos de firewall (figura 16).

Figura 16. Arrancando el servidor y otorgando permisos del Firewall

Arrancado el servidor, es necesario abrir el navegador e ir a la dirección “localhost:3000”, y se mostrará una ventana similar a la figura 17. Esto indica que se ha efectuado el proceso de instalación satisfactoriamente, además de que la aplicación está lista para usarse.

Figura 17. Servidor de Rails arrancado y listo para usarse

Para verificar lo que se acaba de contruir, es necesario ir a la dirección http://localhost:3000/people, en donde se encuentra la funcionalidad recién implementada. Debiéndose ver una imagen similar a la que muestra la figura 18.

Figura 18. Scaffold de la clase persona

Nota:

Si se presenta un error similar al de la figura 19, entonces debe ir al archivo “C:\Sites\persontest\app\views\layouts\application.html.erb” y cambiar el parámetro “application” a “default”, en las líneas 7 y 8.

Figura 19. Error al mostrar la vista del proyecto

Espero te sea de utilidad ;)

Spring Framework

He estado fuera mucho tiempo, así que pensé para volver a escribir por acá; ¿con qué tema empezaré? Entonces tomé la decisión de hablar sobre uno de los frameworks mas populares en cuanto a Java se refiere. En esta primer entrada, definiré los conceptos de Spring, e iré abordando sobre los puntos específicos que se requieren para efectuar una aplicación sencilla que pueda ser funcional.

Sin mas, definamos: Spring es un framework para el desarrollo de aplicaciones y contenedor de inversión de control, de código abierto para la plataforma Java 2​.

Eso del "inversor de control" se refiere a la filosofía "no nos llames, nosotros te llamamos", y se refiere a que es Spring quien tiene el control de la aplicación, no los componentes.

Spring Framework comprende diversos módulos que proveen un rango de servicios:

• Contenedor de inversión de control: permite la configuración de los componentes de aplicación y la administración del ciclo de vida de los objetos Java, se lleva a cabo principalmente a través de la inyección de dependencias.
• Programación orientada a aspectos: habilita la implementación de rutinas transversales.
• Acceso a datos: se trabaja con RDBMS en la plataforma java, usando Java Database Connectivity y herramientas de Mapeo objeto relacional con bases de datos NoSQL.
• Gestión de transacciones: unifica distintas APIs de gestión y coordina las transacciones para los objetos Java.
• Modelo vista controlador: Un framework basado en HTTP y servlets, que provee herramientas para la extensión y personalización de aplicaciones web y servicios web REST.
• Framework de acceso remoto: Permite la importación y exportación estilo RPC, de objetos Java a través de redes que soporten RMI, CORBA y protocolos basados en HTTP incluyendo servicios web (SOAP).
• Convención sobre Configuración: el módulo Spring Roo ofrece una solución rápida para el desarrollo de aplicaciones basadas en Spring Framework, privilegiando la simplicidad sin perder flexibilidad.
• Procesamiento por lotes: un framework para procesamiento de mucho volumen que como características incluye funciones de registro/trazado, manejo de transacciones, estadísticas de procesamiento de tareas, reinicio de tareas, y manejo de recursos.
• Autenticación y Autorización: procesos de seguridad configurables que soportan un rango de estándares, protocolos, herramientas y prácticas a través del subproyecto Spring Security (antiguamente Acegi).
• Administración Remota: Configuración de visibilidad y gestión de objetos Java para la configuración local o remota vía JMX. 
• Mensajes: Registro configurable de objetos receptores de mensajes, para el consumo transparente desde la a través de JMS, una mejora del envío de mensajes sobre las API JMS estándar.
• Testing: Soporte de clases para desarrollo de unidades de prueba e integración.

A pesar de que tomé estas definiciones de la wikipedia, es mas cierto que las tomé de base e hice un mini-resumen de la parte que en verdad es importante.

Les dejo un enlace con un tutorial de MitoCode muy bueno sobre conceptos y definiciones. Ya que posteriormente estaré subiendo contenido de configuraciones.

Espero te sea de utilidad ;)

Franz: ¡Una aplicación para el chat de todas tus aplicaciones!

Hola! Hace algún tiempo vengo sintiéndome un poco incómodo por mis programas de mensagería: Skype, Messenger para Facebook y WhatsApp.

Y el problema es que los ocupo demasiado. Pero llega un momento en que me hostiga tener tantas ventanas abiertas. Suele suceder.

Por ello me di a la tarea de buscar una app que as englobara en una sola y encontré "Franz", una app en la que puedes registrar tus servicios de mensajería y ¡estar con todos en una sola ventana!

Aunque parece que no es mas que una interfaz entre el web y el programa, no deja de sorprender su eficiencia.

Es genial, yo la empecé a usar hace poco y la verdad ¡¡es muy eficiente!!.


La puedes descargar de aquí.

Espero te haya sido de utilidad ;)

MySQL y Procedimientos Almacenados

Algo que se vuelve tedioso es cuando una consulta se empieza a hacer muy grande y resulta horroroso ponerla en el $sql del php, o algo similar en otros lenguajes de programación.

La solución que encontré desde hace mucho tiempo es efectuar las consultas mediante llamadas a procedimientos almacenados y es realmente muy fácil.

Lo que se hace difícil es como implementarlo.

Primero que nada se requiere un "cliente" que haga simple la escritura del código, mientras que algunos programadores se van por el sublime text, yo he preferido usar HeidiSQL, un cliente para MySQL bastante potente y ¡gratuito!.

Para efectuar tu procedimiento almacenado te dejo el siguiente "template"

drop procedure if exists _SPProcedimiento_Prueba;

DELIMITER //

create procedure _SPProcedimiento_Prueba(

xClave varchar(8)

)

begin

Select campo_1, campo_2, campo_3 from tabla_campos where tabla_campos.clave = xClave;

end

//

Delimiter ;

call _SPProcedimiento_Prueba('t001')

Lo que el código hace es lo siguiente:

• En la primera línea "drop procedure..." lo que hace es que se le está indicando que si el procedimiento ya existe, se debe eliminar. Muy útil cuando ya tienes el procedimiento y quieres sobre-escribirlo una y otra vez.
• Las partes del "DELIMITER" son indicaciones para decirle que tome lo que esté en ese bloque como parte del código.
• Las partes Begin y End encierran el proceso, tal como si fueran las {} de los lenguajes como C o Java.
• La línea donde se encuentra el "xClave", es la parte donde se le agregan los parámetros, esto es, variables que quieras incluir en tu código o consulta.
• La parte "Select..", Es donde podemos implementar las consultas que deseemos hacer, y se puede implementar los parámetros que recibimos (xClave).
• La parte del "call _SPProcedimiento_Prueba('t001')" es en donde se llama a la rutina, la instrucción es "call", seguida del nombre del procedimiento que se creó.

Lo que resta es mostrar un pantallazo de cómo se ve esto en HeidiSQL, para que se note el porqué se ocupa esta herramienta.

Espero te sea de utilidad ;)

DUMP de una objeto en Java

En muchas ocasiones me ha ocurrido que quiero revisar el contenido de mis objetos y revisar cuales son los valores que tiene asignados, infortunadamente no hay una función en Java que permita hacer ese comportamiento similar al print_r() o var_dump() del tan famoso PHP.

Afortunadamente leí por ahí un truco y quiero compartirlo con ustedes. Es una implementación simple pero con mucho potencial y consiste en recorrer en un ciclo todos los campos de una clase, sabiendo el nombre, se obtiene su valor y se imprime por consola. Veamos:

Field[] fields = obj.getClass().getDeclaredFields();
try {

     //recorremos el array obtenido a través de nuestro objeto
    for (Field field : fields) {  
               
        //field.getName() da el nombre del campo y field.get obtiene el valor
        System.out.println(field.getName() + " : " + field.get(obj));  
           
     }
} catch (IllegalArgumentException | IllegalAccessException ex) {
      Logger.getLogger(JavaDump.class.getName()).log(Level.SEVERE, null, ex);
}

Como pueden ver, es muy simple el aplicarlo, solo hay que crear la clase que se quiere extraer, y mandarsela como parámetro a esta función.

Si te interesa el proyecto, dejo el proyecto de Netbeans y las clases por separado, para que en caso de no tener este IDE, puedas intentarlo por tu cuenta.

Aquí el proyecto de NetBeans

Aquí las clases por separado

Espero te sea de utilidad ;)

Eliminar una base de datos PostgreSQL de manera Forzada

En esta ocasión me tocó resolver algo sencillo pero un poco difícil de notar.

El percance fué que creé una base de datos en postgres "mi_base", la cual pesaba unos 3.4 gigas, cuando se terminó de usar me disponía a eliminarla y ¡Oh sorpresa!, no permitía eliminar, ya que habían "conexiones activas", cosa que no era cierto, ya que el único usuario se había desconectado hacía unos minutos.

Para no dar mas vueltas, la solución está en revisar las conexiones existentes a esa base de datos y matarlas (¡qué sádico!, ¿No?).

Lo primero es loguearse como super usuario en postgres, psql -Upostgres. Posteriormente, hay que consultar la tabla pg_stat_activity se la manera siguiente

SELECT procpid, current_query FROM pg_stat_activity where datname = 'mi_base';

De donde "mi_base" es la base de datos que no se puede eliminar, y revisamos el campo "procpid", ese es el id del proceso que está causando problemas.

Teniendo ese PID identificado, nos disponemos a matarlo (¡qué sádico!, ¿No?).

kill -TERM procpid

De donde procpid es el número entero del proceso a terminar. Hecho esto, lo siguiente ya es normal: ejecutar el drop database.

drop database mi_base;

Con esto ya debería ser posible eliminar la base de datos sin problema. Debo mencionar que la versión del servidor que estoy trabajando es postgres 8.2.

Espero te sea de utilidad :)

Construyendo una mini aplicación insertar datos con PHP y MySQL

Seguramente sabrás que PHP es uno de los lenguajes de programación mas populares del mundo en cuanto a programación web se refiere.
El dia de hoy, efectué un video en donde, mediante PHP, jQuery, HTML y ajax (si quieres ver la explicación detallada de AJAX puedes hacer click aquí) inserté datos a una base de datos de MySQL.
Sin mas rodeos, dejo el enlace al video donde efectué el proceso.

Espero te sea de utilidad :)

AJAX: Hacer una llamada al servidor

Hola!
Hace poco tuve que trabajar con JSP y mi servidor java, al principio pensé en que podía hacer, ya que anteriormente web lo trabajé con PHP y también con .Net, luego recordé que AJAX se encarga de la comunicación hacia el servidor con un estándar bastante bien definido y en adelante fue todo miel sobre hojuelas.

Pero no se diga mas, a continuación voy mostrarles una llamada al servidor y trataré de explicar cómo es la función y que debería ponerse en cada lugar.

También les comento que es mediante una función dentro de javascript, para que quede todo bastante claro.

En este segmento de 8 lineas, yo hice una llamada al servidor JSP y recibí datos del proceso. Voy a explicar lo que hace linea unida con una fleca en la imagen.

1. El parámetro "type" indica de que modo se hará la llamada, en este caso será via POST (también es posible hacerlo via GET.
2. url: indica la dirección donde se tiene la página del servidor, pudiendo ser por ejemplo "/procesos/llamada.php".
3. async: indica si será asincrono o síncrono, esta propiedad pronto dejará de usarse, ya que afecta el rendimiento de la página cuando se hace de manera síncrona (contradiciendo el paradigma de ajax).  Mas información sobre async aquí.
4. data: indica los datos que se van a enviar en el servidor, se hace de la forma "variable : valor", de esta forma le indicamos que "variable" es la variable que va a ser asignada del lado del servidor, y "valor" es la variable que tenemos del lado del cliente en javascript.
5. success: la variable "xResultado" es una variable que recibe la respuesta del servidor, es decir, todo lo que querramos enviar se almacenará en esa variable, adaptándose al tipo de dato enviado, pudiendo ser un objeto por ejemplo.
6. La línea del console.log() la ocupo para revisar si se está recibiendo correctamente la información, esto es posible verlo con la herramienta del navegador, en chrome por ejemplo, se puede ver cuando se activa la función "inspeccionar elemento --> console".

Con lo anteriormente explicado, es posible iniciarse a hacer llamadas.

Espero te sea de utilidad :)

 

Instalando Apache-Tomcat en MAC Parte 2

En la entrada anterior, se trató acerca del cómo se puede configurar Apache-Tomcat en MAC, lo que veremos ahora es como configurar el servicio para que arranque junto con el sistema operativo.

1. El primer paso es llamar al autómator (cmd + espacio -> automator)
   
2. Seleccionamos nuevo documento
   
3. Elegimos la opción "Flujo de Trabajo"
   
4. Cuando se nos diga que tipo de flujo, escogeremos la opción "Ejecutar el script shell"
   
5. Inmediatamente, teclearemos la instrucción "sh /Library/apache-tomcat/bin/startup.sh", lo que esto quiere decir, es que estoy ejecutando el script de arranque de tomcat  "/startup.sh" ubicado en la carpeta "/Library/apache-tomcat/bin/", en el artículo anterior expliqué como ubicar y nombrar la carpeta de Tomcat, por lo que si vienes de ahí, no es necesario dar mayor explicación.
   
6. Guarda el archivo generado como tipo "Aplicación", en la misma ubicación en que se encuentra "/startup.sh", para que no exista algún conflicto.
7. Ahora, será necesario ir a Preferencias del Sistema -> Usuarios y Grupos -> Arranque, agregar la app que acabamos de crear, y hacer check en ella para que se habilite. Con esto, el servicio de Tomcat ha quedado configurado para que nuestro Sistema operativo arranque en automático a Tomcat, y nuestra aplicación inicie junto a lo demás.
   

Espero te sea de utilidad :)

Si lo que necesitas es configurar el servidor tomcat, puedes ir a la primera parte de este tutorial haciendo click aquí.

Instalando Apache-Tomcat en MAC Parte 1

Es común encontrar en internet información "a medias", la cual funciona hasta cierto punto y encontramos errores a media secuencia.
Bueno, lo que traigo para ustedes es una serie de pasos que yo empleo cuando debo instalar un servidor Tomcat sobre Mac.

1. El primer paso es ir a descargar la versión ZIP del software en la página oficial http://tomcat.apache.org/download-70.cgi 
2. Teniendo ya esta versión, descomprimir la carpeta y renombrarla a algo mas sencillo, como "apache-tomcat". En este momento descargué la versión "apache-tomcat-7.0.64.zip", pero funciona igual de bien con la 8.
3. Es necesario copiar esta carpeta hacia /Library
4. Una vez copiada, otorgamos los permisos sobre ella (cmd + i, Figura 1). La manera mas fácil es darle permisos de Lectura-Escritura a todos los usuarios, luego de que la configuración esté terminada, se podrá jugar con ello.

   

   Figura 1. Permisos para la carpeta

5. Dado los permisos, lo que sigue es arranchar el servicio, esto es posible accediendo a "/Library/apache-tomcat/bin/" y ejecutando el archivo "startup.sh", con esto el servicio arrancará, y podrás acceder vía navegador a la página principal con la ruta: 127.0.0.1:8080 (Figura 2).

   

   Figura 2. Acceso a la página principal.

6. Ahora es necesario configurar usuario y contraseña del usuario administrador, para lo cual es necesario es ir a "/Library/apache-tomcat/conf/" y editar el archivo "tomcat-users.xml", ahora se debe agregar usuario y contraseña, necesarias para desplegar nuestras aplicaciones. Ingresar al final del archivo:

   <tomcat-users xmlns="http://tomcat.apache.org/xml"

   
   
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
                 version="1.0">
   
   

   <role rolename="manager-gui"></role>
   <user username="admin" password="admin" roles="manager-gui"></user>

   </tomcat-users>

   El archivo debería quedar como en la imagen 3.
   

   

   Figura 3. Archivo tomcat-users.xml

   
   
7. Hecho esto, es posible entrar a la página de administrador (figura 4), donde basta elegir nuestra aplicación y desplegarla
   

   

   Figura 4. Administrador de aplicaciones de Tomcat

8. Teniendo en cuenta lo anterior, se debe mencionar que nuestro servidor permanecerá corriendo en tanto no se reinicie la máquina. Pero esto no representa mayor problema, ya que es perfectamente configurable arrancarlo junto con el sistema operativo, lo cual se verá en la segunda parte de este artículo, y que puedes consultar aquí. 

Espero esto te sea de utilidad :)