lunes, 29 de agosto de 2016

How to set up a JDBC Connection Pool on Glassfish

Un pool de conexiones es una clase java que tiene abiertas varias conexiones a base de datos. Cada vez que un programa cliente necesita comunicarse con una base de datos, establece una conexión, generalmente utilizando un protocolo especializado. Esta conexión, generalmente se mantiene abierta el tiempo que dura la ejecución del programa y sólo es cerrada al finalizar el trabajo de la aplicación con la base de datos.

Este artículo muestra la secuencia de pasos a seguir para poder configurar un pool de conexiones en un servidor de aplicaciones Glassfish. Los pasos a seguir son los siguientes:


Luego de configurado el nombre y seleccionado el motor de base de datos, debemos especificar ciertos parámetros de conexión. Si alguno de ellos no existe, se podrá agregar haciendo clic en el botón Add Property.


Podemos hacer una prueba del funcionamiento de nuestro pool de conexiones haciendo clic en el botón Ping.


Si al hacer clic en Ping les aparece el siguiente error: "Ping Connection Pool failed for SakilaPool. Class name is wrong or classpath is not set for : com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource Please check the server.log for more details.", no desesperen. Este error se debe a que no se encuentra la biblioteca correspondiente al conector MySQL en el dominio del servidor.

La solución es muy sencilla, sólo debemos colocar el archivo de extensión jar en su lugar correspondiente y reiniciar el servicio.



Volvemos a hacer ping al JDB Connection Pool y la respuesta debería ser como la que se muestra a continuación.


Ahora sólo basta configurar el acceso al pool como recurso nombrado. Para esto, hacer clic en el botón New de la pantalla que se muestra a continuación:


Y luego hacer clic en OK. Con esto tendremos configurado todo y sólo restaría hacer consultas de prueba a la base de datos a través del pool de conexiones.


Para realizar las pruebas debemos crear un proyecto Java Web y en la página de inicio deberá ser similar a:

<%@page import="java.sql.ResultSet"%> 
<%@page import="java.sql.Statement"%> 
<%@page import="javax.sql.DataSource"%> 
<%@page import="java.sql.Connection"%> 
<%@page import="javax.naming.InitialContext"%> 
<%@page import="javax.naming.Context"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <%
            Context ctx = new InitialContext();
            DataSource ds = (DataSource) ctx.lookup("jdbc/sakila");
            Connection con = ds.getConnection();
            if (con != null) {
                Statement st = con.createStatement();
                ResultSet rs = st.executeQuery("SELECT * FROM actor");
                out.print("<table>");
                while (rs.next()) {
                    out.print("<tr>");
                    out.print("<td>" + rs.getString("first_name") + "</td>");
                    out.print("<td>" + rs.getString("last_name") + "</td>");
                    out.print("</tr>");
                }
                out.print("</table>");
                rs.close();
                st.close();
                con.close();
            }%>
    </body>
</html>
La salida deberá verse así:


Espero este artículo les sea de utilidad. Cualquier pregunta, no duden en comentarla.

jueves, 25 de agosto de 2016

Authentication with JAX-WS SOAP header

Una de las formas más comunes de autenticación en servicios Web es a través de credenciales del tipo usuario y contraseña, agregados como cabeceras en una solicitud SOAP. En este artículo les voy a mostrar la manera cómo enviar estos parámetros desde el cliente hacia el servidor, en donde serán recuperados para posteriormente ejecutar la lógica de autenticación requerida.

Como primer paso, se debe crear en Netbeans un proyecto Java Web para luego crear la estructura de paquetes que se muestra a continuación.


Se debe crear una Interface Notificador en donde se declarará el método que será implementado por nuestro servicio Web. En este caso, la funcionalidad a implementar será la de responder con un saludo a un nombre que se recibirá como parámetro.
package com.rolandopalermo.blog.interfaces;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService
public interface Notificador {

    @WebMethod
    public String saludar(String nombre);
}

Como se puede apreciar, dos anotaciones fueron agregadas. La primera es @WebService y se utiliza para indicar que una clase está implementando un servicio Web o que una Service Endpoint Interface está implementando una interfaz de servicio Web. La segunda anotación, @WebMethod, indica que un método es una operación de servicio Web.

Ahora toca implementar la interfaz creada anteriormente. Dicha implementación se realizará a través de un servicio Web, tal como se muestra a continuación:



/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.rolandopalermo.blog.ws;

import com.rolandopalermo.blog.interfaces.Notificador;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.jws.WebService;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;

@WebService(serviceName = "NotificadorImpl")
public class NotificadorImpl implements Notificador {

    @Resource
    private WebServiceContext wsc;

    @Override
    public String saludar(String nombre) {
        /*Lectura de parámetros de cabecera SOAP*/
        MessageContext mc = wsc.getMessageContext();
        Map requestHeader = (Map) mc.get(MessageContext.HTTP_REQUEST_HEADERS);
        List usuarioList = (List) requestHeader.get("usuario");
        List passwrdList = (List) requestHeader.get("password");
        //***************************************************
        String usuario = "";
        String password = "";
        if (usuarioList != null && passwrdList != null) {
            usuario = (String) usuarioList.get(0);
            password = (String) passwrdList.get(0);
            if (usuario.equals("admin") && password.equals("123456")) {
                if (nombre != null && nombre.length() > 0) {
                    return "Hola " + nombre;
                }
                return "Error";
            } else {
                return "Error de autenticación";
            }
        } else {
            return "Se requiere campos de autenticación";
        }
    }
}
El último paso que resta, en el lado del servidor, sería el despliegue del proyecto. Para esto, hacer lo siguiente:


Y para finalizar, sólo resta escribir el código correspondiente a los clientes. Para el caso de Netbeans, se tendría que crear un servicio Web cliente con el WSDL del servicio Web. Si no enviamos los parámetros de autenticación, la respuesta del servicio será la siguiente:


Por otra parte, si enviamos los parámetros requeridos, tal como se muesta a continuación, la respuesta debe ser la correspondiente a un usuario correctamente autenticado.
package com.rolandopalermo.blog.cliente;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.handler.MessageContext;

public class Main {
    
    private static final String WS_URL = "http://localhost:8080/SOAPAuthentication/NotificadorImpl?wsdl";
    
    public static void main(String[] args) {
        
        com.rolandopalermo.blog.ws.NotificadorImpl_Service service = new com.rolandopalermo.blog.ws.NotificadorImpl_Service();
        com.rolandopalermo.blog.ws.NotificadorImpl port = service.getNotificadorImplPort();
        
        Map<String, Object> req_ctx = ((BindingProvider)port).getRequestContext();
        req_ctx.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, WS_URL);

        Map<String, List<String>> headers = new HashMap<String, List<String>>();
        headers.put("usuario", Collections.singletonList("admin"));
        headers.put("password", Collections.singletonList("123456"));
        req_ctx.put(MessageContext.HTTP_REQUEST_HEADERS, headers);
        
        System.out.println(port.saludar("Rolando"));
        
    }
}

Al ejecutar dicho código, la respuesta será la siguiente:


Código fuente del proyecto:


Espero que este post les sea de utilidad. Cualquier consulta, no duden de escribirla en la caja de comentarios, saludos!

viernes, 30 de octubre de 2015

Enviar correo con Matlab y Gmail


UserName = 'emisor@gmail.com';
passWord = '';
setpref('Internet','E_mail',UserName);
setpref('Internet','SMTP_Server','smtp.gmail.com');
setpref('Internet','SMTP_Username',UserName);
setpref('Internet','SMTP_Password',passWord);
props = java.lang.System.getProperties;
props.setProperty('mail.smtp.auth','true');
props.setProperty('mail.smtp.socketFactory.class', ...
                  'javax.net.ssl.SSLSocketFactory');
props.setProperty('mail.smtp.socketFactory.port','465');
emailto = 'receptor@gmail.com'; % recipient's email
sendmail(emailto, 'My Subject', 'My message');

miércoles, 23 de septiembre de 2015

Obtener imagen de Cámara IP con Matlab


% Obtener imagen de cámara IP
clc;
clear;
figure;
while(1)
%--Definición de variables
url='http://192.168.2.157/image/jpeg.cgi'; 
snapshot1='image_cam_1.jpg';
user='admin';
pass='admin';
%--
urlwrite(url,snapshot1,'Authentication','Basic','Username',user,'Password',pass);
I1 = imread(snapshot1);
imshow(I1);
delete(snapshot1);
end

Sensor HC-SR04 de ultrasonido y Arduino Mega 2560

#define PIN_TRIG 12
#define PIN_ECO  13

void setup() {
  // Inicializacion de la comunicacion serial
  Serial.begin (9600);
  // Inicializacion de pines digitales
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECO, INPUT);
}

void loop() {
  long duracion, distancia;  // Variables
  /* Hacer el disparo */
  digitalWrite(PIN_TRIG, LOW);  
  delayMicroseconds(2); 
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  /* Recepcion del eco de respuesta */
  duracion = pulseIn(PIN_ECO, HIGH);
  /* Calculo de la distancia efectiva */
  distancia = (duracion/2) / 29;
  /* Imprimir resultados a la terminal serial */
  if (distancia >= 500 || distancia <= 0){
    Serial.println("Fuera de rango");
  }
  else {
    Serial.print(distancia);
    Serial.println(" cm");
  }  
  // Retardo para disminuir la frecuencia de las lecturas
  delay(500);  
}

Leer entrada analógica en Arduino con potenciómetro

Lee la entrada analógica A0 cuyo valor está determinado por un potenciómetro y lo muestra a través de la consola serial.
void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(1);
}

Encender un led con Arduino

void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

miércoles, 21 de enero de 2015

Operador de resolución de visibilidad en C++

El operador de resolución de visibilidad (scope resolution operator) '::' permite acceder a una variable global que está solapada por una variable local del mismo nombre.
#include <iostream>

using namespace std;

int variable = 10;

int main()
{
 int variable = 5;
 cout << "La variable local es " << variable << endl;
 cout << "La variable global es " << ::variable;
 cin.get();
 return 0;
}
Este operador no permite acceder a una variable local que está declarada en un bloque más exterior y que se encuentra oculta por una variable del mismo nombre.

martes, 3 de junio de 2014

Importar clases estáticas en Java

Con la finalidad de acceder a métodos estáticos, es necesario especificar la clase de la que ellos provienen. A partir del JDK 1.5, Java nos proporciona un mecanismo que nos permite acceder a miembros estáticos sin la necesidad de especificar la clase a la que pertenecen.
El siguiente ejemplo nos muestra cómo sería un programa normal en Java:
public class Demo {

    public static void main(String[] args) {

        try {
            double r = Math.cos(Math.PI * 5.0);
            System.out.println("El valor de r es = " + r);
        } catch (Exception ex) {
            System.err.println("Error: " + ex);
        }

    }
}
Y utilizando la declaración static import:
import static java.lang.System.out;
import static java.lang.System.err;
import static java.lang.Math.*;

public class Demo {

    public static void main(String[] args) {

        try {
            double r = cos(PI * 5.0);
            out.println("El valor de r es = " + r);
        } catch (Exception ex) {
            err.println("Error: " + ex);
        }

    }
}
La declaración static import es análoga a la declaración import, pues mientras la segunda importa toda clases desde paquetes permitiendo su uso sin la especificación de los paquetes de donde provienen, la declaración static import permite la importación de clases permitiendo el uso de sus miembros estáticos sin la especificación de la clase de la que provienen.

lunes, 2 de junio de 2014

Controlar el tiempo de espera al consumir un webservice

Durante los últimos días, al consumir los Webservice del SRI hemos podido notar que muchas veces se queda en espera sin retornar el objeto de respuesta. Es por eso que es importante controlar el tiempo de espera máximo en nuestra aplicación (Timeout). Para aquellos quienes estén usando el JDK 1.6 este código les servirá para poder establecer un mecanismo de control:
port = service.getRecepcionComprobantesPort();
((BindingProvider) port).getRequestContext().put("com.sun.xml.internal.ws.connect.timeout", 5000);
((BindingProvider) port).getRequestContext().put("com.sun.xml.internal.ws.request.timeout", 5000);
Espero que este código les sea de utilidad y no se olviden de seguirnos a través de nuestra página en Facebook.